vol.h

Go to the documentation of this file.

/*
 * (c) Copyright 2011-2013, Hewlett-Packard Development Company, LP
 */

#ifndef __VOL_H
#define __VOL_H

#include "w_defines.h"
#include "stnode_page.h"

#include <list>
#include <cstdlib>
#include <chrono>

class backup_alloc_cache_t;
class alloc_cache_t;
class stnode_cache_t;
class sm_options;
class chkpt_t;

class vol_t {
public:
    vol_t(const sm_options&);

    virtual ~vol_t();

    void shutdown();

    size_t num_used_pages() const;

    alloc_cache_t* get_alloc_cache() {
        return _alloc_cache;
    }

    stnode_cache_t* get_stnode_cache() {
        return _stnode_cache;
    }

    rc_t write_many_pages(
            PageID first_page,
            const generic_page* buf,        //caller must align this buffer
            int cnt);

    rc_t write_page(PageID page, generic_page* buf) {
        return write_many_pages(page, buf, 1);
    }

    rc_t read_page(PageID page, generic_page* const buf);

    void read_vector(PageID first_pid, unsigned count,
                     std::vector<generic_page*>& pages, bool from_backup);

    rc_t read_many_pages(
            PageID first_page,
            generic_page* const buf,        //caller must align this buffer
            int cnt);

    void read_backup(PageID first, size_t count, void* buf);

    rc_t write_backup(PageID first, size_t count, void* buf);

    bool open_backup();

    void close_backup();

    rc_t sx_add_backup(const string& path, lsn_t backupLSN, bool redo = false);

    void list_backups(std::vector<string>& backups);

    void sync();

    rc_t alloc_a_page(PageID& pid, StoreID stid = 0);

    rc_t deallocate_page(const PageID& pid);

    bool is_allocated_page(PageID pid) const;

    bool is_valid_store(StoreID f) const;

    bool is_alloc_store(StoreID f) const;

    rc_t set_store_root(StoreID snum, PageID root);

    PageID get_store_root(StoreID f) const;

    rc_t create_store(PageID&, StoreID&);

    lsn_t get_backup_lsn();

    void set_readonly(bool r) {
        spinlock_write_critical_section cs(&_mutex);
        _readonly = r;
    }

    rc_t take_backup(string path, bool forceArchive = false);

    unsigned num_backups() const;

    PageID get_last_allocated_pid() const;

    void build_caches(bool truncate, chkpt_t* = nullptr);

    bool caches_ready() {
        return _alloc_cache && _stnode_cache;
    }

private:
    // variables read from volume header -- remain constant after mount
    int _fd;

    mutable srwlock_t _mutex;

    std::chrono::high_resolution_clock::duration _fake_read_latency;

    std::chrono::high_resolution_clock::duration _fake_write_latency;

    alloc_cache_t* _alloc_cache;

    stnode_cache_t* _stnode_cache;

    bool _readonly;

    bool _no_db_mode;

    std::vector<string> _backups;

    std::vector<lsn_t> _backup_lsns;

    int _backup_fd;

    lsn_t _current_backup_lsn;

    unique_ptr<backup_alloc_cache_t> _backup_alloc_cache;

    int _backup_write_fd;

    string _backup_write_path;

    bool _log_page_reads;

    bool _log_page_writes;

    bool _prioritize_archive;

    bool _use_o_sync;

    bool _use_o_direct;

    bool _cluster_stores;
};

inline bool vol_t::is_valid_store(StoreID f) const {
    return (f < stnode_page::max);
}

#endif // __VOL_H /*</std-footer>*/