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

   1 /*
   2  * Copyright 2012 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Paweł Dziepak, pdziepak@quarnos.org
   7  */
   8 #ifndef INODE_H
   9 #define INODE_H
  10
  11
  12 #include "DirectoryCache.h"
  13 #include "MetadataCache.h"
  14 #include "NFS4Inode.h"
  15 #include "OpenState.h"
  16
  17
  18 class Delegation;
  19
  20 class Inode : public NFS4Inode {
  21 public:
  22         static                  status_t        CreateInode(FileSystem* fs, const FileInfo& fi,
  23                                                                         Inode** inode);
  24         virtual                                         ~Inode();
  25
  26         inline                  ino_t           ID() const;
  27         inline                  mode_t          Type() const;
  28         virtual                 const char*     Name() const;
  29         inline                  FileSystem*     GetFileSystem() const;
  30
  31         inline                  void            SetOpenState(OpenState* state);
  32
  33         inline                  void*           FileCache();
  34                                         status_t        RevalidateFileCache();
  35
  36         inline                  uint64          MaxFileSize();
  37
  38         inline                  uint64          Change();
  39         inline                  bool            Dirty();
  40
  41         inline                  OpenState*      GetOpenState();
  42
  43                                         void            SetDelegation(Delegation* delegation);
  44                                         void            RecallDelegation(bool truncate = false);
  45                                         void            RecallReadDelegation();
  46
  47                                         status_t        LookUp(const char* name, ino_t* id);
  48
  49                                         status_t        Access(int mode);
  50
  51                                         status_t        Commit();
  52                                         status_t        SyncAndCommit(bool force = false);
  53
  54                                         status_t        CreateObject(const char* name, const char* path,
  55                                                                         int mode, FileType type, ino_t* id);
  56
  57                                         status_t        CreateLink(const char* name, const char* path,
  58                                                                         int mode, ino_t* id);
  59
  60                                         status_t        Link(Inode* dir, const char* name);
  61                                         status_t        Remove(const char* name, FileType type,
  62                                                                         ino_t* id = NULL);
  63         static                  status_t        Rename(Inode* from, Inode* to,
  64                                                                         const char* fromName, const char* toName,
  65                                                                         bool attribute = false, ino_t* id = NULL,
  66                                                                         ino_t* oldID = NULL);
  67
  68                                         status_t        Stat(struct stat* st,
  69                                                                         OpenAttrCookie* attr = NULL);
  70                                         status_t        WriteStat(const struct stat* st, uint32 mask,
  71                                                                         OpenAttrCookie* attr = NULL);
  72
  73                                         status_t        Create(const char* name, int mode, int perms,
  74                                                                         OpenFileCookie* cookie,
  75                                                                         OpenDelegationData* data, ino_t* id);
  76                                         status_t        Open(int mode, OpenFileCookie* cookie);
  77                                         status_t        Close(OpenFileCookie* cookie);
  78
  79                                         status_t        OpenAttr(const char* name,  int mode,
  80                                                                         OpenAttrCookie* cookie, bool create,
  81                                                                         int32 type = 0);
  82                                         status_t        CloseAttr(OpenAttrCookie* cookie);
  83
  84                                         status_t        Read(OpenFileCookie* cookie, off_t pos,
  85                                                                         void* buffer, size_t* length);
  86                                         status_t        Write(OpenFileCookie* cookie, off_t pos,
  87                                                                         const void* buffer, size_t* _length);
  88
  89                                         status_t        ReadDirect(OpenStateCookie* cookie, off_t pos,
  90                                                                         void* buffer, size_t* length, bool* eof);
  91                                         status_t        WriteDirect(OpenStateCookie* cookie, off_t pos,
  92                                                                         const void* buffer, size_t* _length);
  93
  94                                         status_t        CreateDir(const char* name, int mode,
  95                                                                         ino_t* id);
  96                                         status_t        OpenDir(OpenDirCookie* cookie);
  97                                         status_t        ReadDir(void* buffer, uint32 size,
  98                                                                         uint32* count, OpenDirCookie* cookie);
  99
 100                                         status_t        OpenAttrDir(OpenDirCookie* cookie);
 101
 102                                         status_t        TestLock(OpenFileCookie* cookie,
 103                                                                         struct flock* lock);
 104                                         status_t        AcquireLock(OpenFileCookie* cookie,
 105                                                                         const struct flock* lock, bool wait);
 106                                         status_t        ReleaseLock(OpenFileCookie* cookie,
 107                                                                         const struct flock* lock);
 108                                         status_t        ReleaseAllLocks(OpenFileCookie* cookie);
 109
 110                                         status_t        GetDirSnapshot(DirectoryCacheSnapshot**
 111                                                                         _snapshot, OpenDirCookie* cookie,
 112                                                                         uint64* _change, bool attribute);
 113
 114                                         status_t        LoadAttrDirHandle();
 115
 116         static inline   ino_t           FileIdToInoT(uint64 fileid);
 117
 118                                         void            BeginAIOOp();
 119                                         void            EndAIOOp();
 120         inline                  void            WaitAIOComplete();
 121 protected:
 122                                                                 Inode();
 123
 124                                         void            ReleaseOpenState();
 125
 126                                         status_t        CreateState(const char* name, int mode,
 127                                                                         int perms, OpenState* state,
 128                                                                         OpenDelegationData* data);
 129
 130                                         void            ReturnDelegation(bool truncate);
 131
 132                                         status_t        ReadDirUp(struct dirent* de, uint32 pos,
 133                                                                         uint32 size);
 134                                         status_t        FillDirEntry(struct dirent* de, ino_t id,
 135                                                                         const char* name, uint32 pos, uint32 size);
 136
 137                                         status_t        ChildAdded(const char* name, uint64 fileID,
 138                                                                         const FileHandle& fileHandle);
 139
 140                                         status_t        GetStat(struct stat* st,
 141                                                                         OpenAttrCookie* attr = NULL);
 142
 143                                         char*           AttrToFileName(const char* path);
 144
 145         static inline   status_t        CheckLockType(short ltype, uint32 mode);
 146
 147 private:
 148                                         uint32          fType;
 149
 150                                         MetadataCache   fMetaCache;
 151                                         DirectoryCache* fCache;
 152                                         DirectoryCache* fAttrCache;
 153
 154                                         rw_lock         fDelegationLock;
 155                                         Delegation*     fDelegation;
 156
 157                                         uint64          fChange;
 158                                         void*           fFileCache;
 159                                         mutex           fFileCacheLock;
 160                                         uint64          fMaxFileSize;
 161
 162                                         OpenState*      fOpenState;
 163                                         mutex           fStateLock;
 164
 165                                         rw_lock         fWriteLock;
 166                                         bool            fWriteDirty;
 167
 168                                         sem_id          fAIOWait;
 169                                         uint32          fAIOCount;
 170                                         mutex           fAIOLock;
 171 };
 172
 173
 174 inline void
 175 Inode::WaitAIOComplete()
 176 {
 177         acquire_sem(fAIOWait);
 178         release_sem(fAIOWait);
 179 }
 180
 181
 182 inline ino_t
 183 Inode::FileIdToInoT(uint64 fileid)
 184 {
 185         if (sizeof(ino_t) >= sizeof(uint64))
 186                 return fileid;
 187         else
 188                 return (ino_t)fileid ^ (fileid >>
 189                                         (sizeof(uint64) - sizeof(ino_t)) * 8);
 190 }
 191
 192
 193 inline ino_t
 194 Inode::ID() const
 195 {
 196         return FileIdToInoT(fInfo.fFileId);
 197 }
 198
 199
 200 inline mode_t
 201 Inode::Type() const
 202 {
 203         return sNFSFileTypeToHaiku[fType];
 204 }
 205
 206
 207 inline FileSystem*
 208 Inode::GetFileSystem() const
 209 {
 210         ASSERT(fFileSystem != NULL);
 211         return fFileSystem;
 212 }
 213
 214
 215 inline void*
 216 Inode::FileCache()
 217 {
 218         return fFileCache;
 219 }
 220
 221
 222 inline void
 223 Inode::SetOpenState(OpenState* state)
 224 {
 225         ASSERT(state != NULL);
 226         fOpenState = state;
 227 }
 228
 229
 230 inline uint64
 231 Inode::MaxFileSize()
 232 {
 233         return fMaxFileSize;
 234 }
 235
 236
 237 inline uint64
 238 Inode::Change()
 239 {
 240         return fChange;
 241 }
 242
 243
 244 inline bool
 245 Inode::Dirty()
 246 {
 247         return fWriteDirty;
 248 }
 249
 250
 251 inline OpenState*
 252 Inode::GetOpenState()
 253 {
 254         return fOpenState;
 255 }
 256
 257
 258 #endif  // INODE_H
 259