rom/filesys/fat/lock.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 AROS_ALMOST_COMPATIBLE
  14
  15 #include <aros/macros.h>
  16 #include <exec/types.h>
  17 #include <exec/execbase.h>
  18 #include <exec/memory.h>
  19 #include <dos/dosextens.h>
  20 #include <dos/filehandler.h>
  21
  22 #include <proto/exec.h>
  23 #include <proto/dos.h>
  24 #include <proto/utility.h>
  25
  26 #include <string.h>
  27
  28 #include "fat_fs.h"
  29 #include "fat_protos.h"
  30
  31 #define DEBUG DEBUG_LOCK
  32 #include "debug.h"
  33
  34 #if DEBUG == 0
  35 #define DumpLocks(sb)
  36 #else
  37 void DumpLocks(struct FSSuper *sb)
  38 {
  39     struct GlobalLock *gl;
  40     ULONG count;
  41
  42     bug("[fat] global locks:\n");
  43
  44     ListLength(&sb->info->root_lock.locks, count);
  45     bug("    root: %ld references\n", count);
  46
  47     ForeachNode(&sb->info->locks, gl)
  48     {
  49         ListLength(&gl->locks, count);
  50         bug("    (%ld/%ld) ", gl->dir_cluster, gl->dir_entry);
  51         RawPutChars(&(gl->name[1]), gl->name[0]);
  52         bug(": %ld references\n", count);
  53     }
  54 }
  55 #endif
  56
  57 LONG TestLock(struct ExtFileLock *fl, struct Globals *glob)
  58 {
  59     if (fl == 0 && glob->sb == NULL)
  60     {
  61         if (glob->disk_inserted == FALSE)
  62             return ERROR_NO_DISK;
  63         else
  64             return ERROR_NOT_A_DOS_DISK;
  65     }
  66
  67     if (glob->sb == NULL || glob->disk_inhibited
  68         || (fl && fl->fl_Volume != MKBADDR(glob->sb->doslist)))
  69         return ERROR_DEVICE_NOT_MOUNTED;
  70
  71     if (fl && fl->magic != ID_FAT_DISK)
  72         return ERROR_OBJECT_WRONG_TYPE;
  73
  74     return 0;
  75 }
  76
  77 LONG LockFileByName(struct ExtFileLock *fl, UBYTE *name, LONG namelen,
  78     LONG access, struct ExtFileLock **lock, struct Globals *glob)
  79 {
  80     LONG err = ERROR_OBJECT_NOT_FOUND;
  81     struct DirHandle dh;
  82     struct DirEntry de;
  83     ULONG dir_cluster;
  84
  85     /* if the name is empty, just duplicate the base lock */
  86     if (namelen == 0)
  87         return CopyLock(fl, lock, glob);
  88
  89     /* if the base lock is a file, the name must either be empty (handled
  90      * above) or start with '/' (handled here) */
  91     if (fl != NULL && !(fl->gl->attr & ATTR_DIRECTORY))
  92     {
  93         if (name[0] == '/')
  94         {
  95             if (namelen == 1)
  96                 return OpLockParent(fl, lock, glob);
  97             else
  98             {
  99                 name++;
 100                 namelen--;
 101             }
 102         }
 103         else
 104             return ERROR_OBJECT_WRONG_TYPE;
 105     }
 106
 107     /* the . and .. entries are invisible to the user */
 108     if (name[0] == '.' && (namelen == 1 || (name[1] == '.' && namelen == 2)))
 109     {
 110         D(bug("[fat] not allowing access to '.' or '..' entries\n"));
 111         return ERROR_OBJECT_NOT_FOUND;
 112     }
 113
 114     /* get the first cluster of the directory to look for the file in */
 115     if (fl == NULL)
 116         dir_cluster = 0;
 117     else if (fl->gl->attr & ATTR_DIRECTORY)
 118         dir_cluster = fl->ioh.first_cluster;
 119     else
 120         dir_cluster = fl->gl->dir_cluster;
 121
 122     D(
 123         bug("[fat] trying to obtain lock on '");
 124         RawPutChars(name, namelen);
 125         bug("' in dir at cluster %ld\n", dir_cluster);
 126     )
 127
 128     /* open the dir */
 129     InitDirHandle(glob->sb, dir_cluster, &dh, FALSE);
 130
 131     /* look for the entry */
 132     if ((err = GetDirEntryByPath(&dh, name, namelen, &de)) != 0)
 133     {
 134         ReleaseDirHandle(&dh);
 135         D(bug("[fat] couldn't get lock\n"));
 136         return err;
 137     }
 138
 139     /* found it, do the locking proper */
 140     if (de.e.entry.attr & ATTR_DIRECTORY && FIRST_FILE_CLUSTER(&de)
 141         <= glob->sb->rootdir_cluster)
 142         err = LockRoot(access, lock, glob);
 143     else
 144         err = LockFile(dh.ioh.first_cluster, de.index, access, lock, glob);
 145
 146     ReleaseDirHandle(&dh);
 147
 148     return err;
 149 }
 150
 151 LONG LockFile(ULONG dir_cluster, ULONG dir_entry, LONG access,
 152     struct ExtFileLock **lock, struct Globals *glob)
 153 {
 154     struct GlobalLock *node, *gl;
 155     struct ExtFileLock *fl;
 156     struct DirHandle dh;
 157     struct DirEntry de;
 158     ULONG len;
 159
 160     D(bug("[fat] locking file (%ld/%ld) (%s)\n", dir_cluster, dir_entry,
 161         access == SHARED_LOCK ? "shared" : "exclusive"));
 162
 163     /* first see if we already have a global lock for this file */
 164     gl = NULL;
 165     ForeachNode(&glob->sb->info->locks, node)
 166     {
 167         if (node->dir_cluster == dir_cluster
 168             && node->dir_entry == dir_entry)
 169         {
 170             gl = node;
 171             break;
 172         }
 173     }
 174
 175     /* if we do and we're trying for an exclusive lock, then bail out */
 176     if (gl != NULL && access == EXCLUSIVE_LOCK)
 177     {
 178         D(bug("[fat] can't obtain exclusive lock on already-locked file\n"));
 179         return ERROR_OBJECT_IN_USE;
 180     }
 181
 182     /* allocate space for the lock. we do this first so that we don't go to
 183      * all the effort of setting up the global lock only to have to discard it
 184      * if the filelock allocation fails */
 185     if ((fl = AllocVecPooled(glob->sb->info->mem_pool,
 186         sizeof(struct ExtFileLock))) == NULL)
 187         return ERROR_NO_FREE_STORE;
 188
 189     /* if we don't have a global lock we need to build one */
 190     if (gl == NULL)
 191     {
 192         if ((gl = AllocVecPooled(glob->sb->info->mem_pool,
 193             sizeof(struct GlobalLock))) == NULL)
 194         {
 195             FreeVecPooled(glob->sb->info->mem_pool, fl);
 196             return ERROR_NO_FREE_STORE;
 197         }
 198
 199         gl->dir_cluster = dir_cluster;
 200         gl->dir_entry = dir_entry;
 201         gl->access = access;
 202
 203         /* gotta fish some stuff out of the dir entry too */
 204         InitDirHandle(glob->sb, dir_cluster, &dh, FALSE);
 205         GetDirEntry(&dh, dir_entry, &de);
 206
 207         gl->first_cluster = FIRST_FILE_CLUSTER(&de);
 208         if (gl->first_cluster == 0)
 209             gl->first_cluster = 0xffffffff;
 210
 211         gl->attr = de.e.entry.attr;
 212         gl->size = AROS_LE2LONG(de.e.entry.file_size);
 213
 214         GetDirEntryShortName(&de, &(gl->name[1]), &len);
 215         gl->name[0] = (UBYTE) len;
 216         GetDirEntryLongName(&de, &(gl->name[1]), &len);
 217         gl->name[0] = (UBYTE) len;
 218 #if DEBUG_NAMES
 219         GetDirEntryShortName(&de, &(gl->shortname[1]), &len);
 220         gl->shortname[0] = (UBYTE) len;
 221 #endif
 222
 223         ReleaseDirHandle(&dh);
 224
 225         NEWLIST(&gl->locks);
 226
 227         ADDTAIL(&glob->sb->info->locks, gl);
 228
 229         D(bug("[fat] created new global lock\n"));
 230
 231         /* look through the notify list. if there's any in there that aren't
 232          * currently attached to a global lock, expand them and if they are
 233          * for this file, fill them in */
 234         {
 235             struct NotifyNode *nn;
 236
 237             ForeachNode(&glob->sb->info->notifies, nn)
 238             {
 239                 if (nn->gl == NULL)
 240                 {
 241                     D(bug("[fat] searching for notify name '%s'\n",
 242                         nn->nr->nr_FullName));
 243
 244                     if (InitDirHandle(glob->sb, 0, &dh, TRUE) != 0)
 245                         continue;
 246
 247                     if (GetDirEntryByPath(&dh, nn->nr->nr_FullName,
 248                         strlen(nn->nr->nr_FullName), &de) != 0)
 249                         continue;
 250
 251                     if (gl->dir_cluster == de.cluster
 252                         && gl->dir_entry == de.index)
 253                     {
 254                         D(bug("[fat] found and matched to the global lock"
 255                             " (%ld/%ld)\n",
 256                             gl->dir_cluster, gl->dir_entry));
 257                         nn->gl = gl;
 258                     }
 259                 }
 260             }
 261         }
 262     }
 263
 264     /* now set up the file lock */
 265     fl->fl_Link = BNULL;
 266     fl->fl_Key = 0;
 267     fl->fl_Access = access;
 268     fl->fl_Task = glob->ourport;
 269     fl->fl_Volume = MKBADDR(glob->sb->doslist);
 270
 271     fl->magic = ID_FAT_DISK;
 272
 273     fl->ioh.sb = glob->sb;
 274     fl->ioh.first_cluster = gl->first_cluster;
 275     fl->ioh.block = NULL;
 276     RESET_HANDLE(&(fl->ioh));
 277
 278     fl->pos = 0;
 279
 280     fl->do_notify = FALSE;
 281
 282     fl->gl = gl;
 283     fl->sb = glob->sb;
 284     ADDTAIL(&gl->locks, &fl->node);
 285
 286     D(bug("[fat] created file lock 0x%08x\n", fl));
 287
 288     DumpLocks(glob->sb);
 289
 290     *lock = fl;
 291     return 0;
 292 }
 293
 294 LONG LockRoot(LONG access, struct ExtFileLock **lock, struct Globals *glob)
 295 {
 296     struct ExtFileLock *fl;
 297
 298     D(bug("[fat] locking root\n"));
 299
 300     if (access == EXCLUSIVE_LOCK)
 301     {
 302         D(bug("[fat] can't obtain exclusive lock on the fs root\n"));
 303         return ERROR_OBJECT_IN_USE;
 304     }
 305
 306     if ((fl = AllocVecPooled(glob->sb->info->mem_pool,
 307         sizeof(struct ExtFileLock))) == NULL)
 308         return ERROR_NO_FREE_STORE;
 309
 310     fl->fl_Link = BNULL;
 311     fl->fl_Key = 0;
 312     fl->fl_Access = SHARED_LOCK;
 313     fl->fl_Task = glob->ourport;
 314     fl->fl_Volume = MKBADDR(glob->sb->doslist);
 315
 316     fl->magic = ID_FAT_DISK;
 317
 318     fl->ioh.sb = glob->sb;
 319     fl->ioh.first_cluster = 0;
 320     fl->ioh.block = NULL;
 321     RESET_HANDLE(&(fl->ioh));
 322
 323     fl->pos = 0;
 324
 325     fl->do_notify = FALSE;
 326
 327     if (IsListEmpty(&glob->sb->info->root_lock.locks))
 328         ADDTAIL(&glob->sb->info->locks, &glob->sb->info->root_lock);
 329     fl->gl = &glob->sb->info->root_lock;
 330     fl->sb = glob->sb;
 331     ADDTAIL(&glob->sb->info->root_lock.locks, &fl->node);
 332
 333     D(bug("[fat] created root lock 0x%08x\n", fl));
 334
 335     DumpLocks(glob->sb);
 336
 337     *lock = fl;
 338     return 0;
 339 }
 340
 341 LONG CopyLock(struct ExtFileLock *fl, struct ExtFileLock **lock,
 342     struct Globals *glob)
 343 {
 344     D(bug("[fat] copying lock\n"));
 345
 346     if (fl == NULL || fl->gl == &glob->sb->info->root_lock)
 347         return LockRoot(SHARED_LOCK, lock, glob);
 348
 349     if (fl->fl_Access == EXCLUSIVE_LOCK)
 350     {
 351         D(bug("[fat] can't copy exclusive lock\n"));
 352         return ERROR_OBJECT_IN_USE;
 353     }
 354
 355     return LockFile(fl->gl->dir_cluster, fl->gl->dir_entry, SHARED_LOCK,
 356         lock, glob);
 357 }
 358
 359 void FreeLock(struct ExtFileLock *fl, struct Globals *glob)
 360 {
 361     struct NotifyNode *nn;
 362
 363     if (fl == NULL)
 364         return;
 365
 366     D(bug("[fat] freeing lock 0x%08x\n", fl));
 367
 368     if (fl->do_notify)
 369         SendNotifyByLock(fl->ioh.sb, fl->gl);
 370
 371     REMOVE(&fl->node);
 372
 373     if (IsListEmpty((struct List *)&fl->gl->locks))
 374     {
 375         REMOVE(fl->gl);
 376
 377         ForeachNode(&fl->sb->info->notifies, nn)
 378             if (nn->gl == fl->gl)
 379                 nn->gl = NULL;
 380
 381         if (fl->gl != &fl->sb->info->root_lock)
 382             FreeVecPooled(glob->sb->info->mem_pool, fl->gl);
 383
 384         D(bug("[fat] freed associated global lock\n"));
 385     }
 386
 387     DumpLocks(fl->sb);
 388     if (fl->ioh.block != NULL)
 389         Cache_FreeBlock(fl->sb->cache, fl->ioh.block);
 390
 391     if (fl->sb != glob->sb)
 392         AttemptDestroyVolume(fl->sb);
 393
 394     FreeVecPooled(glob->sb->info->mem_pool, fl);
 395 }