workbench/fs/ntfs/main.c

   1 /*
   2  * ntfs.handler - New Technology FileSystem handler
   3  *
   4  * Copyright © 2012 The AROS Development Team
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the same terms as AROS itself.
   8  *
   9  * $Id $
  10  */
  11
  12 #include <aros/asmcall.h>
  13 #include <aros/macros.h>
  14 #include <exec/types.h>
  15 #include <exec/execbase.h>
  16 #include <exec/memory.h>
  17 #include <dos/dos.h>
  18 #include <dos/dosextens.h>
  19 #include <dos/dostags.h>
  20 #include <dos/filehandler.h>
  21 #include <devices/trackdisk.h>
  22
  23 #include <proto/exec.h>
  24 #include <proto/dos.h>
  25
  26 #include <string.h>
  27
  28 #include "ntfs_fs.h"
  29 #include "ntfs_protos.h"
  30 #include "charset.h"
  31
  32 #include "debug.h"
  33
  34 struct DosLibrary *DOSBase;
  35 struct Library *UtilityBase;
  36 struct Library *IntuitionBase;
  37 struct Library *UUIDBase;
  38 struct Library *CodesetsBase = NULL;
  39
  40 struct Globals global_data;
  41 struct Globals *glob = &global_data;
  42
  43 const TEXT version_string[] = "$VER: ntfs.handler 41.53 (11.02.2012)";
  44
  45 void handler(void)
  46 {
  47     struct Message *msg;
  48     struct DosPacket *startuppacket;
  49     LONG error = ERROR_NO_FREE_STORE;
  50
  51     D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
  52
  53     memset(glob, 0, sizeof(struct Globals));
  54     NEWLIST(&glob->sblist);
  55     glob->ourtask = FindTask(NULL);
  56     glob->ourport = &((struct Process *)glob->ourtask)->pr_MsgPort;
  57     WaitPort(glob->ourport);
  58
  59     msg = GetMsg(glob->ourport);
  60     startuppacket = (struct DosPacket *) msg->mn_Node.ln_Name;
  61     glob->devnode = BADDR(startuppacket->dp_Arg3);
  62
  63     D(bug("[NTFS] %s: opening libraries.\n", __PRETTY_FUNCTION__));
  64     D(bug("\tFS task: 0x%p, port 0x%p\n", glob->ourtask, glob->ourport));
  65
  66     glob->notifyport = CreateMsgPort();
  67
  68     if ((DOSBase = (struct DosLibrary*)OpenLibrary("dos.library", 37))) {
  69         if ((IntuitionBase = OpenLibrary("intuition.library", 37))) {
  70             if ((UtilityBase = OpenLibrary("utility.library", 37))) {
  71                 if ((CodesetsBase = OpenLibrary("codesets.library", 0))) {
  72                     if ((UUIDBase = OpenLibrary("uuid.library", 0))) {
  73                         glob->fssm = BADDR(startuppacket->dp_Arg2);
  74
  75                         if ((glob->mempool = CreatePool(MEMF_PUBLIC, DEF_POOL_SIZE, DEF_POOL_THRESHOLD))) {
  76
  77                             error = InitTimer();
  78                             if (!error) {
  79                                 InitCharsetTables();
  80                                 if ((error = InitDiskHandler(glob->fssm)) == 0) {
  81                                     ULONG pktsig = 1 << glob->ourport->mp_SigBit;
  82                                     ULONG diskchgsig = 1 << glob->diskchgsig_bit;
  83                                     ULONG notifysig = 1 << glob->notifyport->mp_SigBit;
  84                                     ULONG timersig = 1 << glob->timerport->mp_SigBit;
  85                                     ULONG mask = pktsig | diskchgsig | notifysig | timersig;
  86                                     ULONG sigs;
  87                                     struct MsgPort *rp;
  88
  89                                     D(bug("\tInitiated device: %s\n", AROS_BSTR_ADDR(glob->devnode->dol_Name)));
  90
  91                                     glob->devnode->dol_Task = glob->ourport;
  92
  93                                     D(bug("[NTFS] %s: returning startup packet\n", __PRETTY_FUNCTION__));
  94
  95                                     rp = startuppacket->dp_Port;
  96                                     startuppacket->dp_Port = glob->ourport;
  97                                     startuppacket->dp_Res1 = DOSTRUE;
  98                                     startuppacket->dp_Res2 = 0;
  99                                     PutMsg(rp, startuppacket->dp_Link);
 100
 101                                     D(bug("[NTFS] %s: Handler init finished.\n", __PRETTY_FUNCTION__));
 102
 103                                     ProcessDiskChange(); /* insert disk */
 104
 105                                     while(!glob->quit) {
 106                                         sigs = Wait(mask);
 107                                         if (sigs & diskchgsig)
 108                                             ProcessDiskChange();
 109                                         if (sigs & pktsig)
 110                                             ProcessPackets();
 111                                         if (sigs & notifysig)
 112                                             ProcessNotify();
 113                                         if (sigs & timersig)
 114                                             HandleTimer();
 115                                     }
 116
 117                                     D(bug("\n[NTFS] %s: Handler shutdown initiated\n", __PRETTY_FUNCTION__));
 118
 119                                     error = 0;
 120                                     startuppacket = NULL;
 121
 122                                     CleanupDiskHandler();
 123                                 }
 124                                 CleanupTimer();
 125                             }
 126                             DeletePool(glob->mempool);
 127                         }
 128                         else
 129                             error = ERROR_NO_FREE_STORE;
 130                     }
 131                     CloseLibrary(CodesetsBase);
 132                 }
 133                 CloseLibrary(UtilityBase);
 134             }
 135             CloseLibrary(IntuitionBase);
 136         }
 137         CloseLibrary((struct Library*)DOSBase);
 138     }
 139
 140     DeleteMsgPort(glob->notifyport);
 141
 142     if (glob->death_packet != NULL)
 143         ReplyPacket(glob->death_packet);
 144
 145     D(bug("[NTFS] %s: The end.\n", __PRETTY_FUNCTION__));
 146     if (startuppacket != NULL) {
 147         D(bug("[NTFS] %s: returning startup packet\n", __PRETTY_FUNCTION__));
 148
 149         startuppacket->dp_Res1 = DOSTRUE;
 150         startuppacket->dp_Res2 = 0;
 151         ReplyPacket(startuppacket);
 152     }
 153
 154     return;
 155 }
 156
 157 static struct IntData
 158 {
 159     struct Interrupt Interrupt;
 160     struct ExecBase *SysBase;
 161     struct Task *task;
 162     ULONG signal;
 163 } DiskChangeIntData;
 164
 165 static AROS_INTH1(DiskChangeIntHandler, struct IntData *,  MyIntData)
 166 {
 167     AROS_INTFUNC_INIT
 168
 169     struct ExecBase *SysBase = MyIntData->SysBase;
 170
 171     D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
 172
 173     Signal(MyIntData->task, MyIntData->signal);
 174     return 0;
 175
 176     AROS_INTFUNC_EXIT
 177 }
 178
 179 LONG InitDiskHandler (struct FileSysStartupMsg *fssm)
 180 {
 181     LONG err;
 182     ULONG diskchgintbit, flags;
 183     IPTR unit;
 184     UBYTE *device;
 185
 186     unit = fssm->fssm_Unit;
 187     flags = fssm->fssm_Flags;
 188
 189     D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
 190
 191     device = AROS_BSTR_ADDR(fssm->fssm_Device);
 192
 193     if ((diskchgintbit = AllocSignal(-1)) >= 0) {
 194         glob->diskchgsig_bit = diskchgintbit;
 195
 196         if ((glob->diskport = CreateMsgPort())) {
 197
 198             if ((glob->diskioreq = CreateIORequest(glob->diskport, sizeof(struct IOExtTD)))) {
 199
 200                 if (OpenDevice(device, unit, (struct IORequest *)glob->diskioreq, flags) == 0) {
 201                     D(bug("[NTFS] %s: %s:%d successfully opened\n", __PRETTY_FUNCTION__, device, unit));
 202                     Probe_64bit_support();
 203
 204                     if ((glob->diskchgreq = AllocVec(sizeof(struct IOExtTD), MEMF_PUBLIC))) {
 205                         CopyMem(glob->diskioreq, glob->diskchgreq, sizeof(struct IOExtTD));
 206
 207                         /* fill interrupt data */
 208                         DiskChangeIntData.SysBase = SysBase;
 209                         DiskChangeIntData.task = glob->ourtask;
 210                         DiskChangeIntData.signal = 1 << diskchgintbit;
 211
 212                         DiskChangeIntData.Interrupt.is_Node.ln_Type = NT_INTERRUPT;
 213                         DiskChangeIntData.Interrupt.is_Node.ln_Pri = 0;
 214                         DiskChangeIntData.Interrupt.is_Node.ln_Name = "NTFS\0";
 215                         DiskChangeIntData.Interrupt.is_Data = &DiskChangeIntData;
 216                         DiskChangeIntData.Interrupt.is_Code = (void (*)(void))AROS_ASMSYMNAME(DiskChangeIntHandler);
 217
 218                         /* fill io request data */
 219                         glob->diskchgreq->iotd_Req.io_Command = TD_ADDCHANGEINT;
 220                         glob->diskchgreq->iotd_Req.io_Data = &DiskChangeIntData.Interrupt;
 221                         glob->diskchgreq->iotd_Req.io_Length = sizeof(struct Interrupt);
 222                         glob->diskchgreq->iotd_Req.io_Flags = 0;
 223
 224                         SendIO((struct IORequest*)glob->diskchgreq);
 225
 226                         D(bug("[NTFS] %s: Disk change interrupt handler installed\n", __PRETTY_FUNCTION__));
 227
 228                         return 0;
 229                     }
 230                     else
 231                         err = ERROR_NO_FREE_STORE;
 232
 233                     CloseDevice((struct IORequest *)glob->diskioreq);
 234                 }
 235                 else
 236                     err = ERROR_DEVICE_NOT_MOUNTED;
 237
 238                 DeleteIORequest(glob->diskioreq);
 239                 glob->diskioreq = NULL;
 240             }
 241             else
 242                 err = ERROR_NO_FREE_STORE;
 243
 244             DeleteMsgPort(glob->diskport);
 245             glob->diskport = NULL;
 246         }
 247         else
 248             err = ERROR_NO_FREE_STORE;
 249
 250         FreeSignal(diskchgintbit);
 251
 252         glob->diskchgsig_bit = 0;
 253     }
 254     else
 255         err = ERROR_NO_FREE_STORE;
 256
 257     return err;
 258 }
 259
 260 void CleanupDiskHandler(void)
 261 {
 262     D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
 263
 264     D(bug("[NTFS] %s: Freeing handler resources:\n", __PRETTY_FUNCTION__));
 265
 266     /* remove disk change interrupt */
 267     glob->diskchgreq->iotd_Req.io_Command = TD_REMCHANGEINT;
 268     glob->diskchgreq->iotd_Req.io_Data = &DiskChangeIntData.Interrupt;
 269     glob->diskchgreq->iotd_Req.io_Length = sizeof(struct Interrupt);
 270     glob->diskchgreq->iotd_Req.io_Flags = 0;
 271
 272     DoIO((struct IORequest*)glob->diskchgreq);
 273     D(bug("[NTFS] %s: Disk change interrupt handler removed\n", __PRETTY_FUNCTION__));
 274
 275     CloseDevice((struct IORequest *)glob->diskioreq);
 276     DeleteIORequest(glob->diskioreq);
 277     FreeVec(glob->diskchgreq);
 278     DeleteMsgPort(glob->diskport);
 279     D(bug("[NTFS] %s: Device closed\n", __PRETTY_FUNCTION__));
 280
 281     glob->diskioreq = NULL;
 282     glob->diskchgreq = NULL;
 283     glob->diskport = NULL;
 284
 285     FreeSignal(glob->diskchgsig_bit);
 286
 287     D(bug("[NTFS] %s: Done.\n", __PRETTY_FUNCTION__));
 288 }