Move global initialization to file_init()

[hed.git] / src / file / file.h

/* The file handling */
/* $Id$ */

/*
 * hed - Hexadecimal editor
 * Copyright (C) 2004  Petr Baudis <pasky@ucw.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef HED__FILE_FILE_H
#define HED__FILE_FILE_H

#include "config.h"

#include <string.h>
#include <sys/stat.h>

#include "eval/eval.h"
#include "file/fixup.h"

#include "file/access.h"
#include "file/cache.h"
#include "file/tree.h"
#include "file/swap.h"
#include "util/lists.h"

/* The block cache is organized as follows:
 *
 * At the start, there are two virtual blocks:
 * --
 *
 * The first block covers the edited file (and has a physical size
 * equal to the size of the file), the second block covers all
 * possible file offsets beyond EOF (and has zero physical size).
 *
 * Then we can do a read and turn the virtual block to two, or shift its
 * start/end:
 * -x-
 *
 * After a while...
 * x-xxx-xx-x-xxxxxxx-x
 *
 * As you can see, virtual blocks can have any size and stretch variably
 * and fill the gaps between real blocks which have a size limit.
 *
 * Now, we can dirty some blocks:
 * x-xxX-xx-x-xxxxxxx-x
 *
 * Even if we insert anything to the block, other blocks aren't touched,
 * except when the block size hits the limit - then, the block will spawn
 * another one:
 * x-xxXX-xx-x-xxxxxxx-x
 *
 * Again, we don't touch other blocks during deletion. Only when the block
 * size hits zero, we kill it:
 * x-xxXX-xx-x-xxxxxx-x
 *
 * Note that we still keep around blocks which have any counterpart in the
 * file, even if they are already dead in our current file image. This is
 * necessary when reading more file blocks to the cache and when commiting
 * the changes, in order to maintain offset consistency.
 *
 * When can size != phys_size?
 * * byte(s) have been INSERTED into this block: size > phys_size
 *      Special case is an entire new block:
 *              in case of virtual blocks, phys_size MUST == 0 (gap)
 * * byte(s) have been ERASED from this block: size < phys_size
 *      Virtual blocks are not permitted
 */

struct file_block {
        struct tree_head t;
        struct list_head lru;

        /* Flags - see BLOCK_xxx below. */
        long flags;

        /* List of blockoff_t offsets which reference this
         * structure.  This is more flexible than refcounting,
         * because you may actually do something to the file_block,
         * as long as you update all the blockoff_t structs.
         */
        struct list_head refs;

        /* These are only valid for non-virtual blocks */
        struct file_data *dataobj;
        size_t dataoff;

        /* Physical position of this block. */
        uoff_t phys_pos;
};

/* A blockoff_t consists of file position, its corresponding
 * block pointer and the offset within that block.
 */
typedef struct {
        off_t pos;
        struct file_block *block;
        uoff_t off;
        struct list_head list;
} blockoff_t;

#define NULL_BLOCKOFF   { 0, NULL, 0 }

#define BLOCK_DIRTY     0x01    /* data has been modified */
#define BLOCK_INSERTED  0x02    /* insert/delete block */
#define BLOCK_EXCACHE   0x04    /* block is NOT in the cache[] array
                                 * and can be freed after it is undirtied */
#define BLOCK_VIRTUAL   0x08    /* "Virtual" block - must never be dirty
                                 * nor excache; data is not valid - only
                                 * size is meaningful. */
#define BLOCK_EOF       0x10    /* Purely virtual block beyond EOF. */

#define block_is_dirty(b)       ((b)->flags & BLOCK_DIRTY)
#define block_set_dirty(b)      ((b)->flags |= BLOCK_DIRTY)
#define block_clear_dirty(b)    ((b)->flags &= ~BLOCK_DIRTY)

#define block_is_inserted(b)    ((b)->flags & BLOCK_INSERTED)
#define block_set_inserted(b)   ((b)->flags |= BLOCK_INSERTED)
#define block_clear_inserted(b) ((b)->flags &= ~BLOCK_INSERTED)

#define block_is_excache(b)     ((b)->flags & BLOCK_EXCACHE)
#define block_set_excache(b)    ((b)->flags |= BLOCK_EXCACHE)
#define block_clear_excache(b)  ((b)->flags &= ~BLOCK_EXCACHE)

#define block_is_virtual(b)     ((b)->flags & BLOCK_VIRTUAL)
#define block_set_virtual(b)    ((b)->flags |= BLOCK_VIRTUAL)
#define block_clear_virtual(b)  ((b)->flags &= ~BLOCK_VIRTUAL)

#define block_is_eof(b)         ((b)->flags & BLOCK_EOF)
#define block_set_eof(b)        ((b)->flags |= BLOCK_EOF)
#define block_clear_eof(b)      ((b)->flags &= ~BLOCK_EOF)

#define block_is_inner_virtual(b)       \
        (((b)->flags & (BLOCK_VIRTUAL | BLOCK_EOF)) == BLOCK_VIRTUAL)

/* flags related to block allocation */
#define BLOCK_ALLOCMASK (BLOCK_EXCACHE)

/* flags related to block state */
#define BLOCK_STATEMASK (BLOCK_DIRTY | BLOCK_INSERTED | BLOCK_VIRTUAL)

static inline unsigned char *
block_data(struct file_block *block)
{
        return block->dataobj
                ? block->dataobj->data + block->dataoff
                : NULL;
}

/* File object */

#define MARKS_COUNT     ('z' - 'a' + 1 + 'Z' - 'A' + 1)

struct file {
        /* The file blocks are sorted by the offset in this list. */
        struct tree blocks;

        /* This list contains clean file-backed blocks.
         * It is sorted from least recently used to most recently used. */
        struct list_head lru;

        /* This cache holds the data for clean file-backed blocks. */
        struct file_cache *cache;

#ifdef CONFIG_READAHEAD
        enum {
                FILE_RA_NONE,     /* No readahead */
                FILE_RA_FORWARD,  /* Read-ahead forwards */
                FILE_RA_BACKWARD  /* Read-ahead backwards */
        } readahead;
#endif

        int fd;                 /* file descriptor for read-only access */
        uoff_t phys_size;       /* physical size on disk */
        uoff_t size;            /* size after modifications */

        const char *name;       /* file name */

        bool modified;
        struct stat s;

#ifdef CONFIG_SWAP
        char *swpname;          /* original swap file name */
        char *newswpname;       /* new swap file name */
        struct swp_file *swp;
        struct file_block *null_block;
#endif

        blockoff_t marks[MARKS_COUNT];
};

#ifdef CONFIG_READAHEAD
static inline void
file_set_readahead(struct file *file, int val)
{
        file->readahead = val;
}
#else
# define file_set_readahead(file,t) do {} while(0)
#endif

static inline uoff_t
file_block_size(struct file_block *block)
{
        return block->t.size;
}

/* Returns true iff the block follows a deletion */
bool block_is_after_erase(const struct tree *tree, struct file_block *block);

/* Returns true iff the block follows an insertion */
bool block_is_after_insert(const struct tree *tree, struct file_block *block);

/*******************************************************************
 * file object API
 */

/* Global initialization */
int file_init(void);

/* Opens a file. */
struct file *file_open(const char *name);

/* Closes the file. */
void file_close(struct file *file);

/* Get the current file size */
static inline
uoff_t file_size(struct file *file)
{
        return file->size;
}

/* Get the blocks tree */
static inline struct tree *
file_blocks(struct file *file)
{
        return &file->blocks;
}

/* Returns true iff the file has been modified */
static inline bool
file_is_modified(struct file *file)
{
        return file->modified;
}

/* Set the modified flag */
static inline void
file_set_modified(struct file *file)
{
        file->modified = true;
}

/* Clear the modified flag */
static inline void
file_clear_modified(struct file *file)
{
        file->modified = false;
}

/* Update the file size from the file system */
int file_update_size(struct file *file);

/* Commits dirty blocks to the file. */
int file_commit(struct file *file);

#ifdef CONFIG_SWAP

/* Return the swp file object */
static inline struct swp_file *
file_swp(struct file *file)
{
        return file->swp;
}

/* Saves dump of internal structures to disk. */
static inline int
file_write_swap(struct file *file)
{
        return swp_write(file_swp(file));
}

/* Loads dump of internal structures associated with given file from disk. */
int file_read_swap(struct file *file);

/* Checks whether a swap file is available. */
int file_checkswp(struct file *file);

/* Remoes dump of internal structures associated with given file from disk. */
int file_rmswp(struct file *file);

#else  /* CONFIG_SWAP */

/* Provide stubs for the non-swap case */

static inline void *
file_swp(struct file *file)
{
        return NULL;
}

static inline int
file_write_swap(struct file *file)
{
        return 0;
}

static inline int
file_read_swap(struct file *file)
{
        return -1;
}

static inline int
file_checkswp(struct file *file)
{
        return 1;
}

static inline int
file_rmswp(struct file *file)
{
        return 0;
}

#endif  /* CONFIG_SWAP */

/* Fetches the required part of the file. The real size is saved to *size.
 * On error, *size == 0, and the call returns NULL.
 * The error code is available in @errno.
 *
 * Please note that even for incomplete reads, the memory pointed at
 * by the return value will be allocated to the full size as specified
 * by *size. So should the buffer be held for a longer time, you might
 * want to reallocate the buffer to the exact length. */
void *file_fetch_block(struct file *file, uoff_t offset, size_t *size);

/* Converts a logical @offset to a block plus offset (@blockoff). Returns
 * non-zero on error, and the error code is available in @errno.
 */
void file_get_blockoff(struct file *file, uoff_t offset, blockoff_t *blockoff);

static inline void file_put_blockoff(blockoff_t *blockoff)
{
        list_del(&blockoff->list);
}

/* Duplicate into an empty blockoff_t */
void file_dup_blockoff(const blockoff_t *src, blockoff_t *dst);

/* Duplicate into an initialized blockoff_t */
void file_dup2_blockoff(const blockoff_t *src, blockoff_t *dst);

#define is_a_blockoff(blockoff) (!!(blockoff)->block)

/* Relative move from a given block offset.
 * If the resulting position is out of bounds (either < 0 or > OFF_MAX),
 * the offset is adjusted to only move to 0 or OFF_MAX.
 * Returns the actual offset which was used.
 */
off_t file_move_relative(blockoff_t *blockoff, off_t num);

/* Given you know that offset is just one byte beyond the last span,
 * get the block which contains byte at @blockoff.
 * If the block is not available, it is loaded from disk, so do not
 * use this function if you only want to iterate through virtual
 * blocks.
 * Returns non-zero on error, and the error code is available in @errno.
 */
int file_next_block(struct file *file, blockoff_t *blockoff);

/* Ensure reads are valid from a block offset.
 * Returns:
 *  <0  on error
 *   0  on success
 */
int file_read_begin(struct file *file, const blockoff_t *blockoff);

static inline void
file_read_end(struct file *file)
{
        fixup_end();
}

/* Copy in @count bytes from file @file at @pos to @buf.
 * Returns number of bytes which were not copied, i.e. zero on success.
 */
size_t file_cpin(struct file *file, void *buf, size_t count,
                 const blockoff_t *pos);

/* Find a given sequence of bytes in the file, starting at the @pos file
 * offset and possibly wrapping around. @dir is +1 or -1. */
int file_find_expr(struct file *file, blockoff_t *pos, int dir, struct expression *expr, reg_callback expr_cb, void *expr_cb_data);
#define FINDOFF_NO_MATCH -1
#define FINDOFF_ERROR    -2

/* Sets a single byte in the file. */
int file_set_byte(struct file *file, blockoff_t *blockoff, unsigned char byte);
/* Sets multiple bytes in the file. */
size_t file_set_block(struct file *file, blockoff_t *blockoff, unsigned char *buf, size_t len);
uoff_t file_set_bytes(struct file *file, blockoff_t *blockoff, unsigned char byte, uoff_t rep);

/* To insert bytes:
 *  1. call file_insert_begin() with the cursor position and store the
 *     insert physical position.
 *  2. call file_insert_byte() and/or file_insert_block() on the insert pos,
 *     possibly repeatedly
 *  3. call file_insert_end() on the insert pos and forget all about it;
 *     be careful with aliases, because the insert might get merged/freed
 */
int file_insert_begin(struct file *file,
                      blockoff_t *blockoff, blockoff_t *blockoff_ins);
void file_insert_end(struct file *file, blockoff_t *blockoff_ins);

/* Inserts a single byte to the file. */
int file_insert_byte(struct file *file, blockoff_t *blockoff, unsigned char byte);
/* Insert a block of bytes to the file. */
size_t file_insert_block(struct file *file, blockoff_t *blockoff, unsigned char *buf, size_t len);

/* The following function is a shorthand for the usual
 * file_insert_begin, file_insert_block, file_insert_end
 * sequence.
 */
size_t file_insert_once(struct file *file, blockoff_t *blockoff,
                        unsigned char *buf, size_t len);

/* Erases a single byte from the file. */
# define file_erase_byte(file,blockoff) (file_erase_block((file),(blockoff),1))

/* Erases a block of bytes from the file. */
size_t file_erase_block(struct file *file, blockoff_t *blockoff, uoff_t len);

/*******************************************************************
 * MARK FUNCTIONS
 */

/* Returns true iff @mark is a valid mark */
static inline bool
file_mark_is_valid(struct file *file, int mark)
{
        return is_a_blockoff(&file->marks[mark]);
}

/* Return pointer to a mark */
static inline blockoff_t*
file_mark(struct file *file, int mark)
{
        return &file->marks[mark];
}

static inline char
ch2mark(char ch)
{
        return ('a' <= ch && ch <= 'z') ? ch - 'a' :
               ('A' <= ch && ch <= 'Z') ? 26 + ch - 'A' :
               -1;
}

#endif