ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/extfs.cpp
(Generate patch)

Comparing BasiliskII/src/extfs.cpp (file contents):
Revision 1.18 by cebix, 2000-07-14T21:29:08Z vs.
Revision 1.25 by cebix, 2001-03-31T14:31:58Z

# Line 1 | Line 1
1   /*
2   *  extfs.cpp - MacOS file system for native file system access
3   *
4 < *  Basilisk II (C) 1997-2000 Christian Bauer
4 > *  Basilisk II (C) 1997-2001 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 49 | Line 49
49   #endif
50  
51   #include "cpu_emulation.h"
52 #include "macos_util.h"
52   #include "emul_op.h"
53   #include "main.h"
54   #include "disk.h"
# Line 72 | Line 71 | enum {
71          fsHFSProcStub = 6,
72          fsDrvStatus = 12,                               // Drive Status record
73          fsFSD = 42,                                             // File system descriptor
74 <        fsPB = 238,                                             // IOParam (for mounting and renaming)
74 >        fsPB = 238,                                             // IOParam (for mounting and renaming), also used for temporary storage
75          fsVMI = 288,                                    // VoumeMountInfoHeader (for mounting)
76          fsParseRec = 296,                               // ParsePathRec struct
77          fsReturn = 306,                                 // Area for return data of 68k routines
# Line 108 | Line 107 | static bool ready = false;
107   static struct stat root_stat;
108  
109   // File system ID/media type
110 < const int16 MY_FSID = 'ba';
111 < const uint32 MY_MEDIA_TYPE = 'basi';
110 > const int16 MY_FSID = EMULATOR_ID_2;
111 > const uint32 MY_MEDIA_TYPE = EMULATOR_ID_4;
112  
113   // CNID of root and root's parent
114   const uint32 ROOT_ID = 2;
# Line 120 | Line 119 | const int STACK_SIZE = 0x10000;
119  
120   // Allocation block and clump size as reported to MacOS (these are of course
121   // not the real values and have no meaning on the host OS)
122 < const int ALBLK_SIZE = 0x4000;
122 > const int AL_BLK_SIZE = 0x4000;
123   const int CLUMP_SIZE = 0x4000;
124  
125   // Drive number of our pseudo-drive
# Line 277 | Line 276 | static void cstr2pstr(char *dst, const c
276          }
277   }
278  
280 // Convert pascal string to C string
281 static void pstr2cstr(char *dst, const char *src)
282 {
283        int size = *src++;
284        while (size--) {
285                char c = *src++;
286                // Note: we are converting Mac '/' characters to host ':' characters here
287                // '/' is not a path separator as this function is only used on object names
288                if (c == '/')
289                        c = ':';
290                *dst++ = c;
291        }
292        *dst = 0;
293 }
294
279   // Convert string (no length byte) to C string, length given separately
280   static void strn2cstr(char *dst, const char *src, int size)
281   {
# Line 423 | Line 407 | void InstallExtFS(void)
407          // FSM present?
408          r.d[0] = gestaltFSAttr;
409          Execute68kTrap(0xa1ad, &r);     // Gestalt()
410 <        D(bug("FSAttr %ld, %08lx\n", r.d[0], r.a[0]));
410 >        D(bug("FSAttr %d, %08x\n", r.d[0], r.a[0]));
411          if ((r.d[0] & 0xffff) || !(r.a[0] & (1 << gestaltHasFileSystemManager))) {
412                  printf("WARNING: No FSM present, disabling ExtFS\n");
413                  return;
# Line 432 | Line 416 | void InstallExtFS(void)
416          // Yes, version >=1.2?
417          r.d[0] = gestaltFSMVersion;
418          Execute68kTrap(0xa1ad, &r);     // Gestalt()
419 <        D(bug("FSMVersion %ld, %08lx\n", r.d[0], r.a[0]));
419 >        D(bug("FSMVersion %d, %08x\n", r.d[0], r.a[0]));
420          if ((r.d[0] & 0xffff) || (r.a[0] < 0x0120)) {
421                  printf("WARNING: FSM <1.2 found, disabling ExtFS\n");
422                  return;
# Line 702 | Line 686 | int16 ExtFSComm(uint16 message, uint32 p
686                  }
687  
688                  case ffsIDDiskMessage: {                // Check if volume is handled by our FS
689 <                        if (ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
689 >                        if ((int16)ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
690                                  return noErr;
691                          else
692                                  return extFSErr;
# Line 966 | Line 950 | static uint32 find_fcb(int16 refNum)
950   static int16 fs_mount_vol(uint32 pb)
951   {
952          D(bug(" fs_mount_vol(%08lx), vRefNum %d\n", pb, ReadMacInt16(pb + ioVRefNum)));
953 <        if (ReadMacInt16(pb + ioVRefNum) == drive_number)
953 >        if ((int16)ReadMacInt16(pb + ioVRefNum) == drive_number)
954                  return noErr;
955          else
956                  return extFSErr;
# Line 1002 | Line 986 | static int16 fs_volume_mount(uint32 pb)
986          WriteMacInt16(vcb + vcbNmRtDirs, 1);            //!!
987          WriteMacInt16(vcb + vcbNmAlBlks, 0xffff);       //!!
988          WriteMacInt32(vcb + vcbAlBlkSiz, AL_BLK_SIZE);
989 <        WriteMacInt32(vcb + vcbClpSiz, CLUMPSIZE);
989 >        WriteMacInt32(vcb + vcbClpSiz, CLUMP_SIZE);
990          WriteMacInt32(vcb + vcbNxtCNID, next_cnid);
991          WriteMacInt16(vcb + vcbFreeBks, 0xffff);        //!!
992          Host2Mac_memcpy(vcb + vcbVN, VOLUME_NAME, 28);
# Line 1253 | Line 1237 | read_next_de:
1237   #endif
1238          WriteMacInt32(pb + ioFlMdDat, st.st_mtime + TIME_OFFSET);
1239  
1240 <        Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1257 <        uint32 type, creator;   // pb may point to kernel space, but stack is switched
1258 <        get_finder_type(full_path, type, creator);
1259 <        WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1260 <        WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1261 <        uint16 fflags;
1262 <        get_finder_flags(full_path, fflags);
1263 <        WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1240 >        get_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1241  
1242          WriteMacInt16(pb + ioFlStBlk, 0);
1243          WriteMacInt32(pb + ioFlLgLen, st.st_size);
# Line 1272 | Line 1249 | read_next_de:
1249  
1250          if (hfs) {
1251                  WriteMacInt32(pb + ioFlBkDat, 0);
1275                Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1252                  WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1253                  WriteMacInt32(pb + ioFlClpSiz, 0);
1254          }
# Line 1297 | Line 1273 | static int16 fs_set_file_info(uint32 pb,
1273          if (S_ISDIR(st.st_mode))
1274                  return fnfErr;
1275  
1276 <        // Set attributes
1277 <        set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1278 <        set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1276 >        // Set Finder info
1277 >        set_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1278 >
1279          //!! times
1280          return noErr;
1281   }
# Line 1389 | Line 1365 | read_next_de:
1365          }
1366          WriteMacInt32(pb + ioFlMdDat, mtime + TIME_OFFSET);
1367          WriteMacInt32(pb + ioFlBkDat, 0);
1368 +
1369 +        get_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1370 +
1371          if (S_ISDIR(st.st_mode)) {
1393                Mac_memset(pb + ioDrUsrWds, 0, SIZEOF_DInfo);
1394                Mac_memset(pb + ioDrFndrInfo, 0, SIZEOF_DXInfo);
1395                uint16 fflags;  // pb may point to kernel space, but stack is switched
1396                get_finder_flags(full_path, fflags);
1397                WriteMacInt16(pb + ioDrUsrWds + frFlags, fflags);
1372  
1373                  // Determine number of files in directory (cached)
1374                  int count;
# Line 1419 | Line 1393 | read_next_de:
1393                  }
1394                  WriteMacInt16(pb + ioDrNmFls, count);
1395          } else {
1422                Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1423                Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1424                uint32 type, creator;   // pb may point to kernel space, but stack is switched
1425                get_finder_type(full_path, type, creator);
1426                WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1427                WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1428                uint16 fflags;
1429                get_finder_flags(full_path, fflags);
1430                WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1396                  WriteMacInt16(pb + ioFlStBlk, 0);
1397                  WriteMacInt32(pb + ioFlLgLen, st.st_size);
1398                  WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
# Line 1456 | Line 1421 | static int16 fs_set_cat_info(uint32 pb)
1421          if (stat(full_path, &st) < 0)
1422                  return errno2oserr();
1423  
1424 <        // Set attributes
1425 <        if (S_ISDIR(st.st_mode)) {
1426 <                set_finder_flags(full_path, ReadMacInt16(pb + ioDrUsrWds + frFlags));
1462 <        } else {
1463 <                set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1464 <                set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1465 <        }
1424 >        // Set Finder info
1425 >        set_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1426 >
1427          //!! times
1428          return noErr;
1429   }
# Line 1548 | Line 1509 | static int16 fs_open(uint32 pb, uint32 d
1509          WriteMacInt32(fcb + fcbCrPs, 0);
1510          WriteMacInt32(fcb + fcbVPtr, vcb);
1511          WriteMacInt32(fcb + fcbClmpSize, CLUMP_SIZE);
1512 <        uint32 type, creator;   // BeOS: fcb may point to kernel space, but stack is switched
1513 <        get_finder_type(full_path, type, creator);
1514 <        WriteMacInt32(fcb + fcbFType, type);
1512 >
1513 >        get_finfo(full_path, fs_data + fsPB, 0, false);
1514 >        WriteMacInt32(fcb + fcbFType, ReadMacInt32(fs_data + fsPB + fdType));
1515 >
1516          WriteMacInt32(fcb + fcbCatPos, fd);
1517          WriteMacInt32(fcb + fcbDirID, fs_item->parent_id);
1518          cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->name);
# Line 1606 | Line 1568 | static int16 fs_get_fcb_info(uint32 pb,
1568  
1569                  // Find FCB by index
1570                  WriteMacInt16(pb + ioRefNum, 0);
1571 <                for (int i=0; i<ReadMacInt16(pb + ioFCBIndx); i++) {
1571 >                for (int i=0; i<(int)ReadMacInt16(pb + ioFCBIndx); i++) {
1572                          D(bug("  indexing FCBs\n"));
1573                          r.a[0] = vcb;
1574                          r.a[1] = pb + ioRefNum;
# Line 1825 | Line 1787 | static int16 fs_read(uint32 pb)
1787          uint32 pos = lseek(fd, 0, SEEK_CUR);
1788          WriteMacInt32(fcb + fcbCrPs, pos);
1789          WriteMacInt32(pb + ioPosOffset, pos);
1790 <        if (actual != ReadMacInt32(pb + ioReqCount))
1790 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1791                  return actual < 0 ? read_err : eofErr;
1792          else
1793                  return noErr;
# Line 1878 | Line 1840 | static int16 fs_write(uint32 pb)
1840          uint32 pos = lseek(fd, 0, SEEK_CUR);
1841          WriteMacInt32(fcb + fcbCrPs, pos);
1842          WriteMacInt32(pb + ioPosOffset, pos);
1843 <        if (actual != ReadMacInt32(pb + ioReqCount))
1843 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1844                  return write_err;
1845          else
1846                  return noErr;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines