rosapps/drivers/ramdrv/minix/inode.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             services/fs/minix/minix.c
   5  * PURPOSE:          Minix FSD
   6  * PROGRAMMER:       David Welch (welch@mcmail.com)
   7  * UPDATE HISTORY:
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ntddk.h>
  13 #include <string.h>
  14 #include "bitops.h"
  15 #include <ntifs.h>
  16
  17 #define NDEBUG
  18 #include <debug.h>
  19
  20 #include "minix.h"
  21
  22 /* FUNCTIONS ****************************************************************/
  23
  24 NTSTATUS MinixDeleteInode(PDEVICE_OBJECT Volume,
  25                           MINIX_DEVICE_EXTENSION* DeviceExt,
  26                           ULONG ino)
  27 {
  28    PULONG Buffer;
  29    ULONG off;
  30
  31    Buffer = ExAllocatePool(NonPagedPool,BLOCKSIZE);
  32    MinixReadSector(Volume, (ino / 8192)+2, (PVOID)Buffer);
  33    off = ino % 8192;
  34    clear_bit(off%32,&Buffer[off/32]);
  35    MinixWriteSector(Volume, (ino / 8192)+2, (PVOID)Buffer);
  36    return(STATUS_SUCCESS);
  37 }
  38
  39 static ULONG MinixAllocateInode(PDEVICE_OBJECT Volume,
  40                                 MINIX_DEVICE_EXTENSION* DeviceExt)
  41 {
  42    ULONG i;
  43    PULONG Buffer;
  44    ULONG ino;
  45
  46    Buffer = ExAllocatePool(NonPagedPool,BLOCKSIZE);
  47    for (i=0; i<DeviceExt->sb->s_imap_blocks; i++)
  48      {
  49         MinixReadSector(Volume,i + 2,Buffer);
  50         ino = find_first_zero_bit(Buffer,8192);
  51         if (ino < 8192)
  52           {
  53              set_bit(ino%32,&Buffer[32]);
  54              MinixWriteSector(Volume,i + 2,Buffer);
  55              ExFreePool(Buffer);
  56              return(ino + (i*8192));
  57           }
  58      }
  59    ExFreePool(Buffer);
  60    return(0);
  61 }
  62
  63 ULONG MinixNewInode(PDEVICE_OBJECT Volume,
  64                     MINIX_DEVICE_EXTENSION* DeviceExt,
  65                     struct minix_inode* new_inode)
  66 {
  67    ULONG ino;
  68
  69    ino = MinixAllocateInode(Volume,DeviceExt);
  70    if (ino == 0)
  71      {
  72         return(0);
  73      }
  74    MinixWriteInode(Volume,DeviceExt,ino,new_inode);
  75    return(ino);
  76 }
  77
  78 NTSTATUS MinixWriteInode(PDEVICE_OBJECT Volume,
  79                          MINIX_DEVICE_EXTENSION* DeviceExt,
  80                          ULONG ino,
  81                          struct minix_inode* result)
  82 {
  83    int block;
  84    char* buffer;
  85    struct minix_inode* inodes;
  86
  87    DPRINT("MinixWriteInode(ino %x, result %x)\n",ino,result);
  88
  89    buffer = ExAllocatePool(NonPagedPool,1024);
  90    inodes = (struct minix_inode *)buffer;
  91
  92    block = 2 + DeviceExt->sb->s_imap_blocks + DeviceExt->sb->s_zmap_blocks
  93            + ((ino-1) / MINIX_INODES_PER_BLOCK);
  94    MinixReadSector(Volume,block,buffer);
  95    memcpy(&inodes[(ino-1)%MINIX_INODES_PER_BLOCK],result,
  96           sizeof(struct minix_inode));
  97    MinixWriteSector(Volume,block,buffer);
  98
  99    ExFreePool(buffer);
 100    return(STATUS_SUCCESS);
 101 }
 102
 103 NTSTATUS MinixReadInode(PDEVICE_OBJECT DeviceObject,
 104                         MINIX_DEVICE_EXTENSION* DeviceExt,
 105                         ULONG ino,
 106                         struct minix_inode* result)
 107 {
 108    int block;
 109    struct minix_inode* inodes;
 110    PVOID BaseAddress;
 111
 112    DPRINT("MinixReadInode(ino %x, result %x)\n",ino,result);
 113
 114    block = 2 + DeviceExt->sb->s_imap_blocks + DeviceExt->sb->s_zmap_blocks
 115            + ((ino-1) / MINIX_INODES_PER_BLOCK);
 116    DPRINT("Reading block %x offset %x\n",block,block*BLOCKSIZE);
 117    DPRINT("Index %x\n",(ino-1)%MINIX_INODES_PER_BLOCK);
 118
 119    BaseAddress = ExAllocatePool(NonPagedPool, PAGE_SIZE);
 120
 121    MinixReadPage(DeviceObject,
 122                  block,
 123                  BaseAddress);
 124
 125    inodes = (struct minix_inode *)(BaseAddress + ((block % 4) * 512));
 126
 127    memcpy(result,
 128           &inodes[(ino-1)%MINIX_INODES_PER_BLOCK],
 129           sizeof(struct minix_inode));
 130    DPRINT("result->i_uid %x\n",result->i_uid);
 131    DPRINT("result->i_size %x\n",result->i_size);
 132
 133    ExFreePool(BaseAddress);
 134
 135    return(STATUS_SUCCESS);
 136 }