rom/filesys/fat/disk.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 #define USE_INLINE_STDARG
  14
  15 #include <exec/types.h>
  16 #include <exec/errors.h>
  17
  18 #include <dos/dos.h>
  19 #include <dos/dosextens.h>
  20 #include <dos/filehandler.h>
  21 #include <devices/newstyle.h>
  22 #include <devices/trackdisk.h>
  23 #include <devices/inputevent.h>
  24
  25 #include <proto/exec.h>
  26 #include <proto/dos.h>
  27
  28 #include <string.h>
  29
  30 #include "fat_fs.h"
  31 #include "fat_protos.h"
  32
  33 #define DEBUG DEBUG_MISC
  34 #include "debug.h"
  35
  36 #ifndef ID_BUSY
  37 #define ID_BUSY 0x42555359
  38 #endif
  39
  40 /* TD64 commands */
  41 #ifndef TD_READ64
  42 #define TD_READ64  24
  43 #define TD_WRITE64 25
  44 #endif
  45
  46 void FillDiskInfo(struct InfoData *id, struct Globals *glob)
  47 {
  48     struct DosEnvec *de = BADDR(glob->fssm->fssm_Environ);
  49
  50     id->id_NumSoftErrors = 0;
  51     id->id_UnitNumber = glob->fssm->fssm_Unit;
  52     id->id_DiskState = ID_VALIDATED;
  53
  54     if (glob->sb)
  55     {
  56         id->id_NumBlocks = glob->sb->total_sectors;
  57         id->id_NumBlocksUsed = glob->sb->total_sectors
  58             - (glob->sb->free_clusters << glob->sb->cluster_sectors_bits);
  59         id->id_BytesPerBlock = glob->sb->sectorsize;
  60
  61         id->id_DiskType = ID_DOS_DISK;
  62
  63         id->id_VolumeNode = MKBADDR(glob->sb->doslist);
  64         id->id_InUse = (IsListEmpty(&glob->sb->info->locks)
  65             && IsListEmpty(&glob->sb->info->notifies)) ? DOSFALSE : DOSTRUE;
  66     }
  67
  68     else
  69     {
  70         id->id_NumBlocks = de->de_Surfaces * de->de_BlocksPerTrack
  71             * (de->de_HighCyl + 1 - de->de_LowCyl) / de->de_SectorPerBlock;
  72         id->id_NumBlocksUsed = id->id_NumBlocks;
  73         id->id_BytesPerBlock = de->de_SizeBlock << 2;
  74
  75         id->id_DiskState = ID_VALIDATED;
  76
  77         if (glob->disk_inhibited)
  78             id->id_DiskType = ID_BUSY;
  79         else if (glob->disk_inserted)
  80             id->id_DiskType = ID_NOT_REALLY_DOS;        //ID_UNREADABLE_DISK;
  81         else
  82             id->id_DiskType = ID_NO_DISK_PRESENT;
  83
  84         id->id_VolumeNode = BNULL;
  85         id->id_InUse = DOSFALSE;
  86     }
  87 }
  88
  89 void SendVolumePacket(struct DosList *vol, ULONG action,
  90     struct Globals *glob)
  91 {
  92     struct DosPacket *dospacket;
  93
  94     dospacket = AllocDosObject(DOS_STDPKT, TAG_DONE);
  95     dospacket->dp_Type = ACTION_DISK_CHANGE;
  96     dospacket->dp_Arg1 = ID_FAT_DISK;
  97     dospacket->dp_Arg2 = (IPTR) vol;
  98     dospacket->dp_Arg3 = action;
  99     dospacket->dp_Port = NULL;
 100
 101     PutMsg(glob->ourport, dospacket->dp_Link);
 102 }
 103
 104 void DoDiskInsert(struct Globals *glob)
 105 {
 106     struct FSSuper *sb;
 107     ULONG err;
 108     struct DosList *dl;
 109     struct VolumeInfo *vol_info = NULL;
 110     struct GlobalLock *global_lock;
 111     struct ExtFileLock *ext_lock;
 112     struct MinNode *lock_node;
 113     APTR pool;
 114     struct NotifyNode *nn;
 115     struct DosList *newvol = NULL;
 116
 117     if (glob->sb == NULL
 118         && (sb = AllocVecPooled(glob->mempool, sizeof(struct FSSuper))))
 119     {
 120         memset(sb, 0, sizeof(struct FSSuper));
 121
 122         sb->glob = glob;
 123         err = ReadFATSuper(sb);
 124         if (err == 0)
 125         {
 126
 127             /* Scan volume list for a matching volume (would be better to
 128              * match by serial number) */
 129             dl = LockDosList(LDF_VOLUMES | LDF_WRITE);
 130             dl = FindDosEntry(dl, sb->volume.name + 1,
 131                 LDF_VOLUMES | LDF_WRITE);
 132             UnLockDosList(LDF_VOLUMES | LDF_WRITE);
 133
 134             if (dl != NULL &&
 135                 CompareDates(&dl->dol_misc.dol_volume.dol_VolumeDate,
 136                     &sb->volume.create_time) != 0)
 137                 dl = NULL;
 138
 139             if (dl != NULL)
 140             {
 141                 dl->dol_Task = glob->ourport;
 142                 sb->doslist = dl;
 143
 144                 D(bug("\tFound old volume.\n"));
 145
 146                 vol_info = BADDR(dl->dol_misc.dol_volume.dol_LockList);
 147
 148 #if 0    /* No point until we match volumes by serial number */
 149                 /* Update name */
 150 #ifdef AROS_FAST_BPTR
 151                 /* ReadFATSuper() sets a null byte after the
 152                  * string, so this should be fine */
 153                 CopyMem(sb->volume.name + 1, dl->dol_Name,
 154                     sb->volume.name[0] + 1);
 155 #else
 156                 CopyMem(sb->volume.name, dl->dol_Name,
 157                     sb->volume.name[0] + 2);
 158 #endif
 159 #endif
 160
 161                 /* Patch locks and notifications to match this handler
 162                  * instance */
 163                 ForeachNode(&vol_info->locks, global_lock)
 164                 {
 165                     ForeachNode(&global_lock->locks, lock_node)
 166                     {
 167                         ext_lock = LOCKFROMNODE(lock_node);
 168                         D(bug("[fat] Patching adopted lock %p. old port = %p,"
 169                             " new port = %p\n", ext_lock,
 170                             ext_lock->fl_Task, glob->ourport));
 171                         ext_lock->fl_Task = glob->ourport;
 172                         ext_lock->sb = sb;
 173                         ext_lock->ioh.sb = sb;
 174                     }
 175                 }
 176
 177                 ForeachNode(&vol_info->root_lock.locks, lock_node)
 178                 {
 179                     ext_lock = LOCKFROMNODE(lock_node);
 180                     D(bug("[fat] Patching adopted ROOT lock %p. old port = %p,"
 181                         " new port = %p\n", ext_lock, ext_lock->fl_Task,
 182                         glob->ourport));
 183                     ext_lock->fl_Task = glob->ourport;
 184                     ext_lock->sb = sb;
 185                     ext_lock->ioh.sb = sb;
 186                 }
 187
 188                 ForeachNode(&vol_info->notifies, nn)
 189                     nn->nr->nr_Handler = glob->ourport;
 190             }
 191             else
 192             {
 193                 D(bug("\tCreating new volume.\n"));
 194
 195                 /* Create transferable core volume info */
 196                 pool =
 197                     CreatePool(MEMF_PUBLIC, DEF_POOL_SIZE,
 198                     DEF_POOL_THRESHOLD);
 199                 if (pool != NULL)
 200                 {
 201                     vol_info =
 202                         AllocVecPooled(pool, sizeof(struct VolumeInfo));
 203                     if (vol_info != NULL)
 204                     {
 205                         vol_info->mem_pool = pool;
 206                         vol_info->id = sb->volume_id;
 207                         NEWLIST(&vol_info->locks);
 208                         NEWLIST(&vol_info->notifies);
 209
 210                         vol_info->root_lock.dir_cluster = FAT_ROOTDIR_MARK;
 211                         vol_info->root_lock.dir_entry = FAT_ROOTDIR_MARK;
 212                         vol_info->root_lock.access = SHARED_LOCK;
 213                         vol_info->root_lock.first_cluster = 0;
 214                         vol_info->root_lock.attr = ATTR_DIRECTORY;
 215                         vol_info->root_lock.size = 0;
 216                         CopyMem(sb->volume.name, vol_info->root_lock.name,
 217                             sb->volume.name[0] + 1);
 218                         NEWLIST(&vol_info->root_lock.locks);
 219                     }
 220
 221                     if ((newvol =
 222                         AllocVecPooled(pool, sizeof(struct DosList))))
 223                     {
 224                         newvol->dol_Next = BNULL;
 225                         newvol->dol_Type = DLT_VOLUME;
 226                         newvol->dol_Task = glob->ourport;
 227                         newvol->dol_Lock = BNULL;
 228
 229                         CopyMem(&sb->volume.create_time,
 230                             &newvol->dol_misc.dol_volume.dol_VolumeDate,
 231                             sizeof(struct DateStamp));
 232
 233                         newvol->dol_misc.dol_volume.dol_LockList =
 234                             MKBADDR(vol_info);
 235
 236                         newvol->dol_misc.dol_volume.dol_DiskType =
 237                             (sb->type == 12) ? ID_FAT12_DISK :
 238                             (sb->type == 16) ? ID_FAT16_DISK :
 239                             (sb->type == 32) ? ID_FAT32_DISK :
 240                             ID_FAT12_DISK;
 241
 242                         if ((newvol->dol_Name = MKBADDR(
 243                             AllocVecPooled(pool, FAT_MAX_SHORT_NAME + 2))))
 244                         {
 245 #ifdef AROS_FAST_BPTR
 246                             /* ReadFATSuper() sets a null byte after the
 247                              * string, so this should be fine */
 248                             CopyMem(sb->volume.name + 1, newvol->dol_Name,
 249                                 sb->volume.name[0] + 1);
 250 #else
 251                             CopyMem(sb->volume.name,
 252                                 BADDR(newvol->dol_Name),
 253                                 sb->volume.name[0] + 2);
 254 #endif
 255
 256                             sb->doslist = newvol;
 257                         }
 258                     }
 259                     if (vol_info == NULL || newvol == NULL)
 260                         DeletePool(pool);
 261                 }
 262             }
 263
 264             sb->info = vol_info;
 265             glob->last_num = -1;
 266
 267             if (dl != NULL)
 268                 SendEvent(IECLASS_DISKINSERTED, glob);
 269             else
 270                 SendVolumePacket(newvol, ACTION_VOLUME_ADD, glob);
 271
 272             D(bug("\tDisk successfully initialised\n"));
 273
 274             return;
 275         }
 276         else if (err == IOERR_BADADDRESS)
 277             ErrorMessageArgs("Your device does not support 64-bit\n"
 278                 "access to the disk while it is needed!\n"
 279                 "In order to prevent data damage access to\n"
 280                 "this disk was blocked.\n"
 281                 "Please upgrade your device driver.", NULL, glob);
 282
 283         FreeVecPooled(glob->mempool, sb);
 284     }
 285
 286     SendEvent(IECLASS_DISKINSERTED, glob);
 287
 288     return;
 289 }
 290
 291 BOOL AttemptDestroyVolume(struct FSSuper *sb)
 292 {
 293     struct Globals *glob = sb->glob;
 294     BOOL destroyed = FALSE;
 295
 296     D(bug("[fat] Attempting to destroy volume\n"));
 297
 298     /* Check if the volume can be removed */
 299     if (IsListEmpty(&sb->info->locks) && IsListEmpty(&sb->info->notifies))
 300     {
 301         D(bug("\tRemoving volume completely\n"));
 302
 303         if (sb == glob->sb)
 304             glob->sb = NULL;
 305         else
 306             Remove((struct Node *)sb);
 307
 308         SendVolumePacket(sb->doslist, ACTION_VOLUME_REMOVE, glob);
 309
 310         FreeFATSuper(sb);
 311         FreeVecPooled(glob->mempool, sb);
 312         destroyed = TRUE;
 313     }
 314
 315     return destroyed;
 316 }
 317
 318 void DoDiskRemove(struct Globals *glob)
 319 {
 320
 321     if (glob->sb)
 322     {
 323         struct FSSuper *sb = glob->sb;
 324
 325         if (!AttemptDestroyVolume(sb))
 326         {
 327             sb->doslist->dol_Task = NULL;
 328             glob->sb = NULL;
 329             D(bug("\tMoved in-memory super block to spare list. "
 330                 "Waiting for locks and notifications to be freed\n"));
 331             AddTail((struct List *)&glob->sblist, (struct Node *)sb);
 332             SendEvent(IECLASS_DISKREMOVED, glob);
 333         }
 334     }
 335 }
 336
 337 void ProcessDiskChange(struct Globals *glob)
 338 {
 339     D(bug("\nGot disk change request\n"));
 340
 341     if (glob->disk_inhibited)
 342     {
 343         D(bug("Disk is inhibited, ignoring disk change\n"));
 344         return;
 345     }
 346
 347     glob->diskioreq->iotd_Req.io_Command = TD_CHANGESTATE;
 348     glob->diskioreq->iotd_Req.io_Data = NULL;
 349     glob->diskioreq->iotd_Req.io_Length = 0;
 350     glob->diskioreq->iotd_Req.io_Flags = IOF_QUICK;
 351     DoIO((struct IORequest *)glob->diskioreq);
 352
 353     if (glob->diskioreq->iotd_Req.io_Error == 0
 354         && glob->diskioreq->iotd_Req.io_Actual == 0)
 355     {
 356         /* Disk has been inserted. */
 357         D(bug("\tDisk has been inserted\n"));
 358         glob->disk_inserted = TRUE;
 359         DoDiskInsert(glob);
 360     }
 361     else
 362     {
 363         /* Disk has been removed. */
 364         D(bug("\tDisk has been removed\n"));
 365         glob->disk_inserted = FALSE;
 366         DoDiskRemove(glob);
 367     }
 368
 369     D(bug("Done\n"));
 370 }
 371
 372 void UpdateDisk(struct Globals *glob)
 373 {
 374     if (glob->sb)
 375     {
 376         Cache_Flush(glob->sb->cache);
 377         /* FIXME: Handle IO errors on disk flush! */
 378     }
 379
 380     glob->diskioreq->iotd_Req.io_Command = CMD_UPDATE;
 381     DoIO((struct IORequest *)glob->diskioreq);
 382
 383     /* Turn off motor (where applicable) if nothing has happened during the
 384      * last timer period */
 385     if (!glob->restart_timer)
 386     {
 387         D(bug("Stopping drive motor\n"));
 388         glob->diskioreq->iotd_Req.io_Command = TD_MOTOR;
 389         glob->diskioreq->iotd_Req.io_Length = 0;
 390         DoIO((struct IORequest *)glob->diskioreq);
 391     }
 392 }
 393
 394 /* Probe the device to determine 64-bit support */
 395 void Probe_64bit_support(struct Globals *glob)
 396 {
 397     struct NSDeviceQueryResult nsd_query;
 398     UWORD *nsd_cmd;
 399
 400     glob->readcmd = CMD_READ;
 401     glob->writecmd = CMD_WRITE;
 402
 403     /* Probe TD64 */
 404     glob->diskioreq->iotd_Req.io_Command = TD_READ64;
 405     glob->diskioreq->iotd_Req.io_Offset = 0;
 406     glob->diskioreq->iotd_Req.io_Length = 0;
 407     glob->diskioreq->iotd_Req.io_Actual = 0;
 408     glob->diskioreq->iotd_Req.io_Data = 0;
 409
 410     if (DoIO((struct IORequest *)glob->diskioreq) != IOERR_NOCMD)
 411     {
 412         D(bug("Probe_64bit_support:"
 413             " device supports 64-bit trackdisk extensions\n"));
 414         glob->readcmd = TD_READ64;
 415         glob->writecmd = TD_WRITE64;
 416     }
 417
 418     /* Probe NSD */
 419     glob->diskioreq->iotd_Req.io_Command = NSCMD_DEVICEQUERY;
 420     glob->diskioreq->iotd_Req.io_Length =
 421         sizeof(struct NSDeviceQueryResult);
 422     glob->diskioreq->iotd_Req.io_Data = (APTR) &nsd_query;
 423
 424     if (DoIO((struct IORequest *)glob->diskioreq) == 0)
 425         for (nsd_cmd = nsd_query.SupportedCommands; *nsd_cmd != 0;
 426             nsd_cmd++)
 427         {
 428             if (*nsd_cmd == NSCMD_TD_READ64)
 429             {
 430                 D(bug("Probe_64bit_support:"
 431                     " device supports NSD 64-bit trackdisk extensions\n"));
 432                 glob->readcmd = NSCMD_TD_READ64;
 433                 glob->writecmd = NSCMD_TD_WRITE64;
 434                 break;
 435             }
 436         }
 437 }
 438
 439 ULONG AccessDisk(BOOL do_write, ULONG num, ULONG nblocks, ULONG block_size,
 440     UBYTE *data, APTR priv)
 441 {
 442     struct Globals *glob = priv;
 443     UQUAD off;
 444     ULONG err;
 445     ULONG start, end;
 446
 447 #if DEBUG_CACHESTATS > 1
 448     ErrorMessage("Accessing %lu sector(s) starting at %lu.\n"
 449         "First volume sector is %lu, sector size is %lu.\n", nblocks, num,
 450         glob->sb->first_device_sector, block_size);
 451 #endif
 452
 453     /* Adjust parameters if range is partially outside boundaries, or
 454      * warn user and bale out if completely outside boundaries */
 455     if (glob->sb)
 456     {
 457         start = glob->sb->first_device_sector;
 458         if (num + nblocks <= glob->sb->first_device_sector)
 459         {
 460             if (num != glob->last_num)
 461             {
 462                 glob->last_num = num;
 463                 ErrorMessage("A handler attempted to %s %lu sector(s)\n"
 464                     "starting from %lu, before the actual volume space.\n"
 465                     "First volume sector is %lu, sector size is %lu.\n"
 466                     "Either your disk is damaged or it is a bug in\n"
 467                     "the handler. Please check your disk and/or\n"
 468                     "report this problem to the developers team.",
 469                     (IPTR) (do_write ? "write" : "read"), nblocks, num,
 470                     glob->sb->first_device_sector, block_size);
 471             }
 472             return IOERR_BADADDRESS;
 473         }
 474         else if (num < start)
 475         {
 476             nblocks -= start - num;
 477             data += (start - num) * block_size;
 478             num = start;
 479         }
 480
 481         end = glob->sb->first_device_sector + glob->sb->total_sectors;
 482         if (num >= end)
 483         {
 484             if (num != glob->last_num)
 485             {
 486                 glob->last_num = num;
 487                 ErrorMessage("A handler attempted to %s %lu sector(s)\n"
 488                     "starting from %lu, beyond the actual volume space.\n"
 489                     "Last volume sector is %lu, sector size is %lu.\n"
 490                     "Either your disk is damaged or it is a bug in\n"
 491                     "the handler. Please check your disk and/or\n"
 492                     "report this problem to the developers team.",
 493                     (IPTR) (do_write ? "write" : "read"), nblocks, num,
 494                     end - 1, block_size);
 495             }
 496             return IOERR_BADADDRESS;
 497         }
 498         else if (num + nblocks > end)
 499             nblocks = end - num;
 500     }
 501
 502     off = ((UQUAD) num) * block_size;
 503
 504     glob->diskioreq->iotd_Req.io_Offset = off & 0xFFFFFFFF;
 505     glob->diskioreq->iotd_Req.io_Actual = off >> 32;
 506
 507     if (glob->diskioreq->iotd_Req.io_Actual && (glob->readcmd == CMD_READ))
 508         return IOERR_BADADDRESS;
 509
 510     glob->diskioreq->iotd_Req.io_Length = nblocks * block_size;
 511     glob->diskioreq->iotd_Req.io_Data = data;
 512     glob->diskioreq->iotd_Req.io_Command =
 513         do_write ? glob->writecmd : glob->readcmd;
 514
 515     err = DoIO((struct IORequest *)glob->diskioreq);
 516
 517     return err;
 518 }