~vkolesnikov/pbxt/pbxt-07-diskfull

/* Copyright (c) 2005 SNAP Innovation GmbH

 *

 * PrimeBase XT

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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

 *

 * 2005-01-24   Paul McCullagh

 *

 * H&G2JCtL

 */

#ifndef __xt_datalog_h__

#define __xt_datalog_h__

 

#include "xt_filesys.h"

 

/*

 * We the size of a data log exceeds the rollover size, and the amount of

 * garbage in the file is greater than the garbage threshold, then

 * the garbage collector is activated.

 */

#define XT_GARBAGE_THRESHOLD    ((double) 30.0)

 

struct XTDatabase;

struct XTDataLog;

struct XTThread;

struct XTTable;

struct XTOpenTable;

 

/* The mode for opening a datalog depends in the value of "space_required" */

#define DL_MODE_NO_OPEN                 ((off_t) 0)

#define DL_MODE_GC_SOURCE               ((off_t) 1)

#define DL_MODE_EXCLUSIVE               ((off_t) 2)

#define DL_MODE_SHARED                  ((off_t) 3)

 

#define XT_DL_STATUS_DELETED    0

#define XT_DL_STATUS_RECORD             10

 

typedef struct XTDataLogHeader {

        XTDiskValue4                            lh_magic_4;

        XTDiskValue4                            lh_size_4;                      /* Must be set to sizeof(XTDataLogHeaderDRec). */

        XTDiskValue8                            lh_free_space_8;        /* The accumulated free space in this file. */

        XTDiskValue8                            lh_file_len_8;          /* The last confirmed correct file length (always set on close). */

} XTDataLogHeaderDRec, *XTDataLogHeaderDPtr;

 

typedef struct XTDataLogBuffer {

        xtWord1                                         lb_status_1;

        XTDiskValue4                            lb_data_size_4;         /* Size of this record data area only. */

        XTDiskValue6                            lb_record_6;            /* A reference to the record (XT_RECORD_REF_SIZE). */

        xtWord1                                         lb_data[XT_VAR_LENGTH];

} XTDataLogBufferDRec, *XTDataLogBufferDPtr;

 

#define XT_LOG_REC_HEADER_SIZE  offsetof(XTDataLogBufferDRec, lb_data)

 

typedef struct XTDataLogRefD {

        XTDiskValue4                            lr_offset_4;            /* No record will be beyond this offset because logs may not grow so big. */

        XTDiskValue2                            lr_log_no_2;            /* This is enough logs per table! */

} XTDataLogRefDRec, *XTDataLogRefDPtr;

 

#define XT_SET_LOG_REF_6(d, l, o)               XT_SET_DISK_6((xtWord1 *) (d), (((xtWord8) (l)) << 32) | ((xtWord8) (o)))               

#define XT_GET_LOG_REF_6(l, o, s)               do { xtWord8 t8 = XT_GET_DISK_6((xtWord1 *) (s)); l = t8 >> 32; o = t8 & (xtWord8) 0xFFFFFFFF; } while (0)

 

typedef struct XTGCData {

        struct XTThread                         *gc_thread;                             /* The data log garbage collector thread. */

        xt_mutex_type                           gc_lock;

        xt_cond_type                            gc_cond;

} XTGCDataRec, *XTGCDataPtr;

 

 

typedef struct XTDataLog {

        struct XTTable                          *dl_tab;                        /* The table of this data log. */

        xtWord4                                         dl_number;

        xtInt4                                          dl_ref_count;           /* The number of times this data log is open. */

 

        /* Field only updated by the sweeper thread: */

        off_t                                           dl_free_space;          /* This is the amount of free space (garbage) in the log. */

 

        xt_mutex_type                           dl_shlock;                      /* This lock is required to use the shared handle (assuming multiple pread are not allowed) */

        XTOpenFilePtr                           dl_shfile;                      /* The shared log handle (this handle is always open) */

 

        /* Fields only updated by the exclusive locker thread: */

#ifdef DEBUG

        struct XTThread                         *dl_exthr;

#endif

        XTOpenFilePtr                           dl_exfile;                                                      /* Non-null of the log is opened exclusively (this handle is append only) */

        xt_rwlock_type                  dl_rwlock;                                                      /* Lock for reading and writing the log buffer. */

        off_t                                           dl_file_size;                                           /* This is the size of the file (i.e. current EOF). */

        u_int                                           dl_offset;                                                      /* Current write position in write buffer. */

        xtWord1                                         dl_buffer[XT_DATA_LOG_BUFFER_SIZE];     /* The log write buffer. */

} XTDataLogRec, *XTDataLogPtr;

 

void    xt_dl_init_tab(struct XTThread *self, struct XTTable *tab);

void    xt_dl_exit_tab(struct XTTable *tab);

void    xt_dl_init_open_tab(struct XTThread *self, struct XTOpenTable *ot, off_t space_required);

void    xt_dl_exit_open_tab(struct XTOpenTable *ot);

 

xtBool  xt_dl_flush_log(XTDataLogPtr dlog);

xtBool  xt_dl_get_log_offset(struct XTOpenTable *ot, off_t *out_offset);

xtBool  xt_dl_append_log(struct XTOpenTable *ot, size_t size, void *data, xtBool may_switch);

xtBool  xt_dl_read_log(struct XTOpenTable *ot, xtWord4 log_no, off_t offset, size_t size, void *data);

xtBool  xt_dl_delete_log(struct XTOpenTable *ot, xtWord4 log_no, off_t offset, size_t size, off_t tab_offset);

 

void    xt_dl_init_db(struct XTThread *self, struct XTDatabase *db);

void    xt_dl_exit_db(struct XTThread *self, struct XTDatabase *db);

void    xt_quit_dl_daemons(struct XTThread *self, struct XTDatabase *db);

void    xt_gc_main(struct XTThread *self, xtBool once_off);

 

#endif