src/add-ons/kernel/file_systems/btrfs/Inode.h

   1 /*
   2  * Copyright 2011, Jérôme Duval, korli@users.berlios.de.
   3  * Copyright 2008, Axel Dörfler, axeld@pinc-software.de.
   4  * This file may be used under the terms of the MIT License.
   5  */
   6 #ifndef INODE_H
   7 #define INODE_H
   8
   9
  10 #include "btrfs.h"
  11 #include "Volume.h"
  12
  13
  14 //#define TRACE_BTRFS
  15 #ifdef TRACE_BTRFS
  16 #       define TRACEI(x...) dprintf("\33[34mbtrfs:\33[0m " x)
  17 #else
  18 #       define TRACEI(x...) ;
  19 #endif
  20
  21
  22 class Inode {
  23 public:
  24                                                 Inode(Volume* volume, ino_t id);
  25                                                 ~Inode();
  26
  27                         status_t        InitCheck();
  28
  29                         ino_t           ID() const { return fID; }
  30
  31                         rw_lock*        Lock() { return& fLock; }
  32
  33                         status_t        UpdateNodeFromDisk();
  34
  35                         bool            IsDirectory() const
  36                                                         { return S_ISDIR(Mode()); }
  37                         bool            IsFile() const
  38                                                         { return S_ISREG(Mode()); }
  39                         bool            IsSymLink() const
  40                                                         { return S_ISLNK(Mode()); }
  41                         status_t        CheckPermissions(int accessMode) const;
  42
  43                         mode_t          Mode() const { return fNode.Mode(); }
  44                         off_t           Size() const { return fNode.Size(); }
  45                         uid_t           UserID() const { return fNode.UserID(); }
  46                         gid_t           GroupID() const { return fNode.GroupID(); }
  47                         void            GetChangeTime(struct timespec& timespec) const
  48                                                         { fNode.GetChangeTime(timespec); }
  49                         void            GetModificationTime(struct timespec& timespec) const
  50                                                         { fNode.GetModificationTime(timespec); }
  51                         void            GetCreationTime(struct timespec& timespec) const
  52                                                         { fNode.GetCreationTime(timespec); }
  53                         void            GetAccessTime(struct timespec& timespec) const
  54                                                         { fNode.GetCreationTime(timespec); }
  55
  56                         Volume*         GetVolume() const { return fVolume; }
  57
  58                         status_t        FindBlock(off_t logical, off_t& physical,
  59                                                         off_t* _length = NULL);
  60                         status_t        ReadAt(off_t pos, uint8* buffer, size_t* length);
  61                         status_t        FillGapWithZeros(off_t start, off_t end);
  62
  63                         void*           FileCache() const { return fCache; }
  64                         void*           Map() const { return fMap; }
  65
  66                         status_t        FindParent(ino_t* id);
  67 private:
  68                                                 Inode(Volume* volume);
  69                                                 Inode(const Inode&);
  70                                                 Inode& operator=(const Inode&);
  71                                                         // no implementation
  72
  73                         uint64          _NumBlocks();
  74
  75                         rw_lock         fLock;
  76                         ::Volume*       fVolume;
  77                         ino_t           fID;
  78                         void*           fCache;
  79                         void*           fMap;
  80                         status_t        fInitStatus;
  81                         btrfs_inode fNode;
  82 };
  83
  84
  85 // The Vnode class provides a convenience layer upon get_vnode(), so that
  86 // you don't have to call put_vnode() anymore, which may make code more
  87 // readable in some cases
  88
  89 class Vnode {
  90 public:
  91         Vnode(Volume* volume, ino_t id)
  92                 :
  93                 fInode(NULL)
  94         {
  95                 SetTo(volume, id);
  96         }
  97
  98         Vnode()
  99                 :
 100                 fStatus(B_NO_INIT),
 101                 fInode(NULL)
 102         {
 103         }
 104
 105         ~Vnode()
 106         {
 107                 Unset();
 108         }
 109
 110         status_t InitCheck()
 111         {
 112                 return fStatus;
 113         }
 114
 115         void Unset()
 116         {
 117                 if (fInode != NULL) {
 118                         put_vnode(fInode->GetVolume()->FSVolume(), fInode->ID());
 119                         fInode = NULL;
 120                         fStatus = B_NO_INIT;
 121                 }
 122         }
 123
 124         status_t SetTo(Volume* volume, ino_t id)
 125         {
 126                 Unset();
 127
 128                 return fStatus = get_vnode(volume->FSVolume(), id, (void**)&fInode);
 129         }
 130
 131         status_t Get(Inode** _inode)
 132         {
 133                 *_inode = fInode;
 134                 return fStatus;
 135         }
 136
 137         void Keep()
 138         {
 139                 TRACEI("Vnode::Keep()\n");
 140                 fInode = NULL;
 141         }
 142
 143 private:
 144         status_t        fStatus;
 145         Inode*          fInode;
 146 };
 147
 148
 149 #endif  // INODE_H