rom/filesys/fat/main.c

   1 /*
   2  * fat-handler - FAT12/16/32 filesystem handler
   3  *
   4  * Copyright © 2006 Marek Szyprowski
   5  * Copyright © 2007-2015 The AROS Development Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the same terms as AROS itself.
   9  *
  10  * $Id$
  11  */
  12
  13 #include <aros/asmcall.h>
  14 #include <aros/macros.h>
  15 #include <exec/types.h>
  16 #include <exec/execbase.h>
  17 #include <exec/memory.h>
  18 #include <dos/dos.h>
  19 #include <dos/dosextens.h>
  20 #include <dos/dostags.h>
  21 #include <dos/filehandler.h>
  22 #include <devices/trackdisk.h>
  23
  24 #include <proto/exec.h>
  25
  26 #include <string.h>
  27
  28 #include "fat_fs.h"
  29 #include "fat_protos.h"
  30
  31 #define DEBUG DEBUG_MISC
  32 #include "debug.h"
  33
  34 #undef SysBase
  35 #undef UtilityBase
  36
  37 static LONG InitDiskHandler(struct Globals *glob);
  38 static void CleanupDiskHandler(struct Globals *glob);
  39
  40 static void InitCharsetTables(struct Globals *glob)
  41 {
  42     int i;
  43
  44     for (i = 0; i < 65536; i++)
  45     {
  46         if (i < 256)
  47         {
  48             glob->from_unicode[i] = i;
  49             glob->to_unicode[i] = i;
  50         }
  51         else
  52             glob->from_unicode[i] = '_';
  53     }
  54 }
  55
  56 static struct Globals *fat_init(struct Process *proc, struct DosPacket *dp,
  57     struct ExecBase *SysBase)
  58 {
  59     struct Globals *glob;
  60
  61     glob = AllocVec(sizeof(struct Globals), MEMF_ANY | MEMF_CLEAR);
  62     if (glob)
  63     {
  64         glob->gl_SysBase = SysBase;
  65         if ((glob->gl_DOSBase =
  66                 (struct DosLibrary *)OpenLibrary("dos.library", 0)))
  67         {
  68             if ((glob->gl_UtilityBase = OpenLibrary("utility.library", 0)))
  69             {
  70                 NEWLIST(&glob->sblist);
  71                 glob->ourtask = &proc->pr_Task;
  72                 glob->ourport = &proc->pr_MsgPort;
  73
  74                 glob->devnode = BADDR(dp->dp_Arg3);
  75
  76                 D(bug("\nFATFS: opening libraries.\n"));
  77                 D(bug("\tFS task: %lx, port %lx\n", glob->ourtask,
  78                     glob->ourport));
  79
  80                 glob->notifyport = CreateMsgPort();
  81
  82                 glob->fssm = BADDR(dp->dp_Arg2);
  83
  84                 if ((glob->mempool = CreatePool(MEMF_PUBLIC, DEF_POOL_SIZE,
  85                     DEF_POOL_THRESHOLD)))
  86                 {
  87                     LONG error = InitTimer(glob);
  88                     if (!error)
  89                     {
  90                         InitCharsetTables(glob);
  91                         if ((error = InitDiskHandler(glob)) == 0)
  92                         {
  93                             return glob;
  94                         }
  95
  96                         CleanupTimer(glob);
  97                     }
  98                     DeletePool(glob->mempool);
  99                 }
 100
 101                 CloseLibrary(glob->gl_UtilityBase);
 102             }
 103
 104             CloseLibrary((struct Library *)glob->gl_DOSBase);
 105         }
 106
 107         FreeVec(glob);
 108     }
 109
 110     return NULL;
 111 }
 112
 113 static void fat_exit(struct Globals *glob)
 114 {
 115     struct ExecBase *SysBase = glob->gl_SysBase;
 116     CleanupDiskHandler(glob);
 117     CleanupTimer(glob);
 118     DeletePool(glob->mempool);
 119
 120     DeleteMsgPort(glob->notifyport);
 121
 122     CloseLibrary(glob->gl_UtilityBase);
 123     CloseLibrary((struct Library *)glob->gl_DOSBase);
 124
 125     FreeVec(glob);
 126 }
 127
 128 LONG handler(struct ExecBase *SysBase)
 129 {
 130     struct Globals *glob;
 131     struct Process *proc;
 132     struct MsgPort *mp;
 133     struct DosPacket *dp;
 134
 135     D(bug("%s: start\n", __func__));
 136
 137     proc = (struct Process *)FindTask(NULL);
 138     mp = &proc->pr_MsgPort;
 139     WaitPort(mp);
 140     dp = (struct DosPacket *)GetMsg(mp)->mn_Node.ln_Name;
 141
 142     D(bug("%s: mp=%p, path='%b'\n", __func__, mp, dp->dp_Arg1));
 143
 144     glob = fat_init(proc, dp, SysBase);
 145
 146     if (!glob)
 147     {
 148         D(bug("%s: %b - error %d\n", __func__, dp->dp_Arg1, RETURN_FAIL));
 149         dp->dp_Res1 = DOSFALSE;
 150         dp->dp_Res2 = ERROR_NO_FREE_STORE;
 151         ReplyPacket(dp, SysBase);
 152         return RETURN_FAIL;
 153     }
 154     else
 155     {
 156         ULONG pktsig = 1 << glob->ourport->mp_SigBit;
 157         ULONG diskchgsig = 1 << glob->diskchgsig_bit;
 158         ULONG notifysig = 1 << glob->notifyport->mp_SigBit;
 159         ULONG timersig = 1 << glob->timerport->mp_SigBit;
 160         ULONG mask = pktsig | diskchgsig | notifysig | timersig;
 161         ULONG sigs;
 162
 163         D(bug("\tInitiated device: %s\n",
 164             AROS_BSTR_ADDR(glob->devnode->dol_Name)));
 165
 166         glob->devnode->dol_Task = glob->ourport;
 167
 168         D(bug("[fat] returning startup packet\n"));
 169
 170         dp->dp_Res1 = DOSTRUE;
 171         dp->dp_Res2 = 0;
 172         ReplyPacket(dp, SysBase);
 173
 174         D(bug("Handler init finished.\n"));
 175
 176         /* Insert disk */
 177         ProcessDiskChange(glob);
 178
 179         while (!glob->quit)
 180         {
 181             sigs = Wait(mask);
 182             if (sigs & diskchgsig)
 183                 ProcessDiskChange(glob);
 184             if (sigs & pktsig)
 185                 ProcessPackets(glob);
 186             if (sigs & notifysig)
 187                 ProcessNotify(glob);
 188             if (sigs & timersig)
 189                 HandleTimer(glob);
 190         }
 191
 192         D(bug("\nHandler shutdown initiated\n"));
 193
 194         dp = NULL;
 195
 196         if (glob->death_packet != NULL)
 197             ReplyPacket(glob->death_packet, SysBase);
 198
 199         fat_exit(glob);
 200     }
 201     D(bug("The end.\n"));
 202
 203     return RETURN_OK;
 204 }
 205
 206 static AROS_INTH1(DiskChangeIntHandler, struct IntData *, MyIntData)
 207 {
 208     AROS_INTFUNC_INIT
 209
 210     struct ExecBase *SysBase = MyIntData->SysBase;
 211
 212     Signal(MyIntData->task, MyIntData->signal);
 213     return 0;
 214
 215     AROS_INTFUNC_EXIT
 216 }
 217
 218 static LONG InitDiskHandler(struct Globals *glob)
 219 {
 220     struct ExecBase *SysBase = glob->gl_SysBase;
 221     struct FileSysStartupMsg *fssm = glob->fssm;
 222     LONG err;
 223     ULONG diskchgintbit, flags;
 224     IPTR unit;
 225     UBYTE *device;
 226
 227     unit = fssm->fssm_Unit;
 228     flags = fssm->fssm_Flags;
 229
 230     device = AROS_BSTR_ADDR(fssm->fssm_Device);
 231
 232     if ((diskchgintbit = AllocSignal(-1)) >= 0)
 233     {
 234         glob->diskchgsig_bit = diskchgintbit;
 235
 236         if ((glob->diskport = CreateMsgPort()))
 237         {
 238
 239             if ((glob->diskioreq = CreateIORequest(glob->diskport,
 240                 sizeof(struct IOExtTD))))
 241             {
 242                 if (OpenDevice(device, unit,
 243                     (struct IORequest *)glob->diskioreq, flags) == 0)
 244                 {
 245                     D(bug("\tDevice successfully opened\n"));
 246                     Probe64BitSupport(glob);
 247
 248                     if ((glob->diskchgreq =
 249                         AllocVec(sizeof(struct IOExtTD), MEMF_PUBLIC)))
 250                     {
 251                         CopyMem(glob->diskioreq, glob->diskchgreq,
 252                             sizeof(struct IOExtTD));
 253
 254                         /* Fill interrupt data */
 255                         glob->DiskChangeIntData.SysBase = SysBase;
 256                         glob->DiskChangeIntData.task = glob->ourtask;
 257                         glob->DiskChangeIntData.signal = 1 << diskchgintbit;
 258
 259                         glob->DiskChangeIntData.Interrupt.is_Node.ln_Type =
 260                             NT_INTERRUPT;
 261                         glob->DiskChangeIntData.Interrupt.is_Node.ln_Pri =
 262                             0;
 263                         glob->DiskChangeIntData.Interrupt.is_Node.ln_Name =
 264                             "FATFS";
 265                         glob->DiskChangeIntData.Interrupt.is_Data =
 266                             &glob->DiskChangeIntData;
 267                         glob->DiskChangeIntData.Interrupt.is_Code =
 268                             (VOID_FUNC)
 269                             AROS_ASMSYMNAME(DiskChangeIntHandler);
 270
 271                         /* Fill I/O request data */
 272                         glob->diskchgreq->iotd_Req.io_Command =
 273                             TD_ADDCHANGEINT;
 274                         glob->diskchgreq->iotd_Req.io_Data =
 275                             &glob->DiskChangeIntData.Interrupt;
 276                         glob->diskchgreq->iotd_Req.io_Length =
 277                             sizeof(struct Interrupt);
 278                         glob->diskchgreq->iotd_Req.io_Flags = 0;
 279
 280                         SendIO((struct IORequest *)glob->diskchgreq);
 281
 282                         D(bug("\tDisk change interrupt handler installed\n"));
 283
 284                         return 0;
 285                     }
 286                     else
 287                         err = ERROR_NO_FREE_STORE;
 288
 289                     CloseDevice((struct IORequest *)glob->diskioreq);
 290                 }
 291                 else
 292                     err = ERROR_DEVICE_NOT_MOUNTED;
 293
 294                 DeleteIORequest(glob->diskioreq);
 295                 glob->diskioreq = NULL;
 296             }
 297             else
 298                 err = ERROR_NO_FREE_STORE;
 299
 300             DeleteMsgPort(glob->diskport);
 301             glob->diskport = NULL;
 302         }
 303         else
 304             err = ERROR_NO_FREE_STORE;
 305
 306         FreeSignal(diskchgintbit);
 307
 308         glob->diskchgsig_bit = 0;
 309     }
 310     else
 311         err = ERROR_NO_FREE_STORE;
 312
 313     return err;
 314 }
 315
 316 static void CleanupDiskHandler(struct Globals *glob)
 317 {
 318     struct ExecBase *SysBase = glob->gl_SysBase;
 319
 320     D(bug("\tFreeing handler resources:\n"));
 321
 322     /* Remove disk change interrupt */
 323     glob->diskchgreq->iotd_Req.io_Command = TD_REMCHANGEINT;
 324     glob->diskchgreq->iotd_Req.io_Data = &glob->DiskChangeIntData.Interrupt;
 325     glob->diskchgreq->iotd_Req.io_Length = sizeof(struct Interrupt);
 326     glob->diskchgreq->iotd_Req.io_Flags = 0;
 327
 328     DoIO((struct IORequest *)glob->diskchgreq);
 329     D(bug("\tDisk change interrupt handler removed\n"));
 330
 331     CloseDevice((struct IORequest *)glob->diskioreq);
 332     DeleteIORequest(glob->diskioreq);
 333     FreeVec(glob->diskchgreq);
 334     DeleteMsgPort(glob->diskport);
 335     D(bug("\tDevice closed\n"));
 336
 337     glob->diskioreq = NULL;
 338     glob->diskchgreq = NULL;
 339     glob->diskport = NULL;
 340
 341     FreeSignal(glob->diskchgsig_bit);
 342
 343     D(bug("\tDone.\n"));
 344 }