fso_cachefile.h

Go to the documentation of this file.

/* BLURB gpl
 
                           Coda File System
                              Release 8
 
          Copyright (c) 1987-2021 Carnegie Mellon University
                  Additional copyrights listed below
 
This  code  is  distributed "AS IS" without warranty of any kind under
the terms of the GNU General Public Licence Version 2, as shown in the
file  LICENSE.  The  technical and financial  contributors to Coda are
listed in the file CREDITS.
 
                        Additional copyrights
              Copyright (c) 2002-2003 Intel Corporation
 
#*/
 
/*
 *
 *    Specification of the Venus File-System Object (fso) abstraction.
 *
 *    ToDo:
 *
 */
 
#ifndef _VENUS_FSO_CACHEFILE_H_
#define _VENUS_FSO_CACHEFILE_H_ 1
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <lwp/lock.h>
 
#ifdef __cplusplus
}
#endif
 
/* from util */
#include <bitmap7.h>
#include <dlist.h>
 
/* Representation of UFS file in cache directory. */
/* Currently, CacheFiles and fsobjs are statically bound to each
   other, one-to-one, by embedding */
/* a single CacheFile in each fsobj.  An fsobj may use its CacheFile
   in several ways (or not at all). */
/* We guarantee that these uses are mutually exclusive (in time,
   per-fsobj), hence the static allocation */
/* policy works.  In the future we may choose not to make the uses
   mutually exclusive, and will then */
/* have to implement some sort of dynamic allocation/binding
   scheme. */
/* The different uses of CacheFile are: */
/*    1. Copy of plain file */
/*    2. Unix-format copy of directory */
 
#define CACHEFILENAMELEN 16
 
extern uint64_t CacheChunkBlockSize;
extern uint64_t CacheChunkBlockSizeBits;
extern uint64_t CacheChunkBlockSizeMax;
extern uint64_t CacheChunkBlockBitmapSize;
 
static inline uint64_t ccblocks_to_bytes(uint64_t ccblocks)
{
    return ccblocks << CacheChunkBlockSizeBits;
}
 
static inline uint64_t bytes_to_ccblocks(uint64_t bytes)
{
    return bytes >> CacheChunkBlockSizeBits;
}
 
static inline uint64_t bytes_to_ccblocks_floor(uint64_t bytes)
{
    return bytes_to_ccblocks(bytes);
}
 
static inline uint64_t bytes_to_ccblocks_ceil(uint64_t bytes)
{
    return bytes_to_ccblocks(bytes + CacheChunkBlockSizeMax);
}
 
static inline uint64_t align_to_ccblock_ceil(uint64_t bytes)
{
    return (bytes + CacheChunkBlockSizeMax) & ~CacheChunkBlockSizeMax;
}
 
static inline uint64_t align_to_ccblock_floor(uint64_t bytes)
{
    return (bytes & ~CacheChunkBlockSizeMax);
}
 
static inline uint64_t ccblock_start(uint64_t b_pos)
{
    return bytes_to_ccblocks_floor(b_pos);
}
 
static inline uint64_t ccblock_end(uint64_t b_pos, int64_t b_count)
{
    return bytes_to_ccblocks_ceil(b_pos + b_count);
}
 
static inline uint64_t ccblock_length(uint64_t b_pos, int64_t b_count)
{
    return ccblock_end(b_pos, b_count) - ccblock_start(b_pos);
}
 
static inline uint64_t pos_align_to_ccblock(uint64_t b_pos)
{
    return (b_pos & ~CacheChunkBlockSizeMax);
}
 
static inline uint64_t length_align_to_ccblock(uint64_t b_pos, int64_t b_count)
{
    return ccblocks_to_bytes(ccblock_length(b_pos, b_count));
}
 
#define FS_BLOCKS_SIZE_MAX (4095)
#define FS_BLOCKS_SIZE_MASK (~FS_BLOCKS_SIZE_MAX)
#define FS_BLOCKS_ALIGN(size) \
    ((size + FS_BLOCKS_SIZE_MAX) & FS_BLOCKS_SIZE_MASK)
 
class CacheChunk : private dlink {
private:
    uint64_t start; 
    int64_t len; 
    bool valid; 
public:
    CacheChunk(uint64_t start, int64_t len)
        : start(start)
        , len(len)
        , valid(true)
    {
    }
 
    CacheChunk()
        : start(0)
        , len(0)
        , valid(false)
    {
    }
 
    uint64_t GetStart() { return start; }
 
    int64_t GetLength() { return len; }
 
    bool isValid() { return valid; }
};
 
class CacheChunkList : private dlist {
    Lock rd_wr_lock; 
public:
    CacheChunkList();
 
    ~CacheChunkList();
 
    void AddChunk(uint64_t start, int64_t len);
 
    bool ReverseCheck(uint64_t start, int64_t len);
 
    void ReverseRemove(uint64_t start, int64_t len);
 
    void ForEach(void (*foreachcb)(uint64_t start, int64_t len,
                                   void *usr_data_cb),
                 void *usr_data = NULL);
 
    void ReadLock();
 
    void ReadUnlock();
 
    void WriteLock();
 
    void WriteUnlock();
 
    CacheChunk pop();
 
    uint Length() { return (uint)this->count(); }
};
 
class CacheFile {
    friend class SegmentedCacheFile;
    uint64_t length; 
    uint64_t
        validdata; 
    int refcnt; 
    int numopens; 
    bitmap7 *cached_chunks; 
    int recoverable; 
    Lock rw_lock; 
    bool isPartial; 
    int ValidContainer();
 
    void UpdateValidData();
 
    CacheChunk GetNextHole(uint64_t start_b, uint64_t end_b);
 
protected:
    char name[CACHEFILENAMELEN]; 
    static int64_t CopySegment(CacheFile *from, CacheFile *to, uint64_t pos,
                               int64_t count) REQUIRES_TRANSACTION;
 
public:
    CacheFile(int i, int recoverable = 1, int partial = 0) REQUIRES_TRANSACTION;
 
    CacheFile();
 
    ~CacheFile();
 
    void Create(int newlength = 0) REQUIRES_TRANSACTION;
 
    int Open(int flags);
 
    int Close(int fd);
 
    FILE *FOpen(const char *mode);
 
    int FClose(FILE *f);
 
    void Validate() EXCLUDES_TRANSACTION;
 
    void Reset() EXCLUDES_TRANSACTION;
 
    int Copy(CacheFile *destination) REQUIRES_TRANSACTION;
 
    int Copy(char *destname, int recovering = 0);
 
    void IncRef() { refcnt++; }
 
    int DecRef();
 
    void Stat(struct stat *tstat);
 
    void Utimes(const struct timeval times[2]);
 
    void Truncate(uint64_t newlen) REQUIRES_TRANSACTION;
 
    void SetLength(uint64_t newlen) REQUIRES_TRANSACTION;
 
    void SetValidData(uint64_t len) REQUIRES_TRANSACTION;
 
    void SetValidData(uint64_t start, int64_t len) REQUIRES_TRANSACTION;
 
    CacheChunkList *GetHoles(uint64_t start, int64_t len);
 
    CacheChunkList *GetValidChunks(uint64_t start, int64_t len);
 
    char *Name() { return (name); }
 
    uint64_t Length() { return (length); }
 
    uint64_t ValidData() { return (validdata); }
 
    uint64_t ConsecutiveValidData();
 
    int IsComplete() { return (length == validdata); }
 
    bool IsPartial() { return isPartial; }
 
    void SetPartial(bool is_partial) REQUIRES_TRANSACTION;
 
    void print() { print(stdout); }
 
    void print(FILE *fp)
    {
        fflush(fp);
        print(fileno(fp));
    }
 
    void print(int fdes);
};
 
class SegmentedCacheFile : public CacheFile {
    CacheFile *cf; 
public:
    SegmentedCacheFile(int i) REQUIRES_TRANSACTION;
 
    ~SegmentedCacheFile();
 
    void Associate(CacheFile *cf) REQUIRES_TRANSACTION;
 
    int64_t ExtractSegment(uint64_t pos, int64_t count) REQUIRES_TRANSACTION;
 
    int64_t InjectSegment(uint64_t pos, int64_t count) REQUIRES_TRANSACTION;
};
 
#endif /* _VENUS_FSO_CACHEFILE_H_ */