Kernel/vfs/io.c

   1 /*
   2  * AcessMicro VFS
   3  * - File IO Passthru's
   4  */
   5 #include <common.h>
   6 #include "vfs.h"
   7 #include "vfs_int.h"
   8
   9 #define DEBUG   0
  10
  11 #if DEBUG
  12 #else
  13 # undef ENTER
  14 # undef LOG
  15 # undef LEAVE
  16 # define ENTER(...)
  17 # define LOG(...)
  18 # define LEAVE(...)
  19 #endif
  20
  21 // === CODE ===
  22 /**
  23  * \fn Uint64 VFS_Read(int FD, Uint64 Length, void *Buffer)
  24  * \brief Read data from a node (file)
  25  */
  26 Uint64 VFS_Read(int FD, Uint64 Length, void *Buffer)
  27 {
  28         tVFS_Handle     *h;
  29         Uint64  ret;
  30
  31         ENTER("iFD XLength pBuffer", FD, Length, Buffer);
  32
  33         h = VFS_GetHandle(FD);
  34         if(!h)  return -1;
  35
  36         if( !(h->Mode & VFS_OPENFLAG_READ) || h->Node->Flags & VFS_FFLAG_DIRECTORY ) {
  37                 LEAVE('i', -1);
  38                 return -1;
  39         }
  40
  41         if(!h->Node->Read) {
  42                 LEAVE('i', 0);
  43                 return 0;
  44         }
  45
  46         ret = h->Node->Read(h->Node, h->Position, Length, Buffer);
  47         if(ret == -1) {
  48                 LEAVE('i', -1);
  49                 return -1;
  50         }
  51
  52         h->Position += ret;
  53         LEAVE('X', ret);
  54         return ret;
  55 }
  56
  57 /**
  58  * \fn Uint64 VFS_ReadAt(int FD, Uint64 Offset, Uint64 Length, void *Buffer)
  59  * \brief Read data from a given offset (atomic)
  60  */
  61 Uint64 VFS_ReadAt(int FD, Uint64 Offset, Uint64 Length, void *Buffer)
  62 {
  63         tVFS_Handle     *h;
  64         Uint64  ret;
  65
  66         h = VFS_GetHandle(FD);
  67         if(!h)  return -1;
  68
  69         if( !(h->Mode & VFS_OPENFLAG_READ) )    return -1;
  70         if( h->Node->Flags & VFS_FFLAG_DIRECTORY )      return -1;
  71
  72         if(!h->Node->Read) {
  73                 Warning("VFS_ReadAt - Node %p, does not have a read method", h->Node);
  74                 return 0;
  75         }
  76         ret = h->Node->Read(h->Node, Offset, Length, Buffer);
  77         if(ret == -1)   return -1;
  78         return ret;
  79 }
  80
  81 /**
  82  * \fn Uint64 VFS_Write(int FD, Uint64 Length, void *Buffer)
  83  * \brief Read data from a node (file)
  84  */
  85 Uint64 VFS_Write(int FD, Uint64 Length, void *Buffer)
  86 {
  87         tVFS_Handle     *h;
  88         Uint64  ret;
  89
  90         h = VFS_GetHandle(FD);
  91         if(!h)  return -1;
  92
  93         if( !(h->Mode & VFS_OPENFLAG_WRITE) )   return -1;
  94         if( h->Node->Flags & VFS_FFLAG_DIRECTORY )      return -1;
  95
  96         if(!h->Node->Write)     return 0;
  97
  98         ret = h->Node->Write(h->Node, h->Position, Length, Buffer);
  99         if(ret == -1)   return -1;
 100         h->Position += ret;
 101         return ret;
 102 }
 103
 104 /**
 105  * \fn Uint64 VFS_WriteAt(int FD, Uint64 Offset, Uint64 Length, void *Buffer)
 106  * \brief Write data to a file at a given offset (atomic)
 107  */
 108 Uint64 VFS_WriteAt(int FD, Uint64 Offset, Uint64 Length, void *Buffer)
 109 {
 110         tVFS_Handle     *h;
 111         Uint64  ret;
 112
 113         h = VFS_GetHandle(FD);
 114         if(!h)  return -1;
 115
 116         if( !(h->Mode & VFS_OPENFLAG_WRITE) )   return -1;
 117         if( h->Node->Flags & VFS_FFLAG_DIRECTORY )      return -1;
 118
 119         if(!h->Node->Write)     return 0;
 120         ret = h->Node->Write(h->Node, Offset, Length, Buffer);
 121         if(ret == -1)   return -1;
 122         return ret;
 123 }
 124
 125 /**
 126  * \fn Uint64 VFS_Tell(int FD)
 127  * \brief Returns the current file position
 128  */
 129 Uint64 VFS_Tell(int FD)
 130 {
 131         tVFS_Handle     *h;
 132
 133         h = VFS_GetHandle(FD);
 134         if(!h)  return -1;
 135
 136         return h->Position;
 137 }
 138
 139 /**
 140  * \fn int VFS_Seek(int FD, Sint64 Offset, int Whence)
 141  * \brief Seek to a new location
 142  * \param FD    File descriptor
 143  * \param Offset        Where to go
 144  * \param Whence        From where
 145  */
 146 int VFS_Seek(int FD, Sint64 Offset, int Whence)
 147 {
 148         tVFS_Handle     *h;
 149
 150         h = VFS_GetHandle(FD);
 151         if(!h)  return -1;
 152
 153         // Set relative to current position
 154         if(Whence == 0) {
 155                 h->Position += Offset;
 156                 return 0;
 157         }
 158
 159         // Set relative to end of file
 160         if(Whence < 0) {
 161                 h->Position = h->Node->Size - Offset;
 162                 return 0;
 163         }
 164
 165         // Set relative to start of file
 166         h->Position = Offset;
 167         return 0;
 168 }
 169
 170 /**
 171  * \fn int VFS_IOCtl(int FD, int ID, void *Buffer)
 172  * \brief Call an IO Control on a file
 173  */
 174 int VFS_IOCtl(int FD, int ID, void *Buffer)
 175 {
 176         tVFS_Handle     *h;
 177
 178         h = VFS_GetHandle(FD);
 179         if(!h)  return -1;
 180
 181         if(!h->Node->IOCtl)     return -1;
 182         return h->Node->IOCtl(h->Node, ID, Buffer);
 183 }
 184
 185 /**
 186  * \fn int VFS_FInfo(int FD, tFInfo *Dest, int MaxACLs)
 187  * \brief Retrieve file information
 188  * \return Number of ACLs stored
 189  */
 190 int VFS_FInfo(int FD, tFInfo *Dest, int MaxACLs)
 191 {
 192         tVFS_Handle     *h;
 193          int    max;
 194
 195         h = VFS_GetHandle(FD);
 196         if(!h)  return -1;
 197
 198         Dest->uid = h->Node->UID;
 199         Dest->gid = h->Node->GID;
 200         Dest->size = h->Node->Size;
 201         Dest->atime = h->Node->ATime;
 202         Dest->ctime = h->Node->MTime;
 203         Dest->mtime = h->Node->CTime;
 204         Dest->numacls = h->Node->NumACLs;
 205
 206         Dest->flags = 0;
 207         if(h->Node->Flags & VFS_FFLAG_DIRECTORY)        Dest->flags |= 0x10;
 208         if(h->Node->Flags & VFS_FFLAG_SYMLINK)  Dest->flags |= 0x20;
 209
 210         max = (MaxACLs < h->Node->NumACLs) ? MaxACLs : h->Node->NumACLs;
 211         memcpy(&Dest->acls, h->Node->ACLs, max*sizeof(tVFS_ACL));
 212
 213         return max;
 214 }
 215
 216 // === EXPORTS ===
 217 EXPORT(VFS_Read);
 218 EXPORT(VFS_Write);
 219 EXPORT(VFS_ReadAt);
 220 EXPORT(VFS_WriteAt);
 221 EXPORT(VFS_IOCtl);
 222 EXPORT(VFS_Seek);
 223 EXPORT(VFS_Tell);