arch/all-unix/devs/hostdisk/hostdisk_host.c

   1 #ifdef HOST_OS_ios
   2
   3 #ifdef __arm__
   4 /*
   5  * Under ARM iOS quadwords are long-aligned, however in AROS (according to AAPCS)
   6  * they are quad-aligned. This macro turns on some tricks which bypass this problem
   7  */
   8 #define HOST_LONG_ALIGNED
   9 #endif
  10 #ifdef __i386__
  11 /*
  12  * Under i386 we pick up MacOS' libSystem.dylib instead of Simulator's libSystem.dylib,
  13  * so we have to use special versions of certain functions. We can't simply #define _DARWIN_NO_64_BIT_INODE
  14  * because iOS SDK forbids this (in iOS inode_t is always 64-bit wide)
  15  */
  16 #define INODE64_SUFFIX "$INODE64"
  17 #endif
  18
  19 /* Correspondingly, there's no struct stat64. Use struct stat instead. */
  20 #define stat64 stat
  21 #else
  22
  23 /*
  24  * Use 32-bit inode_t on Darwin. Otherwise we are expected to use "stat$INODE64"
  25  * instead of "stat" function which is available only on MacOS 10.6.
  26  */
  27 #define _DARWIN_NO_64_BIT_INODE
  28 /* This enables struct stat64 definition */
  29 #define _DARWIN_C_SOURCE        /* For Darwin */
  30 #define _LARGEFILE64_SOURCE     /* For Linux */
  31 #endif
  32
  33 #ifndef INODE64_SUFFIX
  34 #define INODE64_SUFFIX
  35 #endif
  36
  37 #include <aros/debug.h>
  38 #include <aros/symbolsets.h>
  39 #include <devices/trackdisk.h>
  40 #include <exec/errors.h>
  41 #include <proto/exec.h>
  42 #include <proto/hostlib.h>
  43 #include <proto/intuition.h>
  44 #include <proto/kernel.h>
  45
  46 #ifdef HOST_LONG_ALIGNED
  47 #pragma pack(4)
  48 #endif
  49
  50 /* Prevents struct timeval redefinition */
  51 #define timeval sys_timeval
  52
  53 /*
  54  * avoid conflicts between our __unused define and the ones that might come in
  55  * via fcntl.h
  56  */
  57 #undef __unused
  58
  59 #include <errno.h>
  60 #include <fcntl.h>
  61 #include <unistd.h>
  62
  63 #pragma pack()
  64
  65 #include "hostdisk_host.h"
  66 #include "hostdisk_device.h"
  67
  68 static ULONG error(int unixerr)
  69 {
  70     switch (unixerr)
  71     {
  72     case 0:
  73         return 0;
  74
  75     case EBUSY:
  76         return TDERR_DriveInUse;
  77
  78     case EPERM:
  79         return TDERR_WriteProt;
  80
  81     default:
  82         return TDERR_NotSpecified;
  83     }
  84 }
  85
  86 ULONG Host_Open(struct unit *Unit)
  87 {
  88     struct HostDiskBase *hdskBase = Unit->hdskBase;
  89     struct stat64 st;
  90     int err;
  91
  92     D(bug("hostdisk: Host_Open(%s)\n", Unit->filename));
  93
  94     HostLib_Lock();
  95
  96     Unit->file = hdskBase->iface->open(Unit->filename, O_RDWR, 0755, &err);
  97     AROS_HOST_BARRIER
  98     err = *hdskBase->errnoPtr;
  99
 100     if (err == EBUSY)
 101     {
 102         /* This allows to work on Darwin, at least in read-only mode */
 103         D(bug("hostdisk: EBUSY, retrying with read-only access\n", Unit->filename, Unit->file, err));
 104
 105         Unit->file = hdskBase->iface->open(Unit->filename, O_RDONLY, 0755, &err);
 106         AROS_HOST_BARRIER
 107         err = *hdskBase->errnoPtr;
 108     }
 109
 110     HostLib_Unlock();
 111
 112     if (Unit->file == -1)
 113     {
 114         D(bug("hostdisk: Error %d\n", err));
 115
 116         return error(err);
 117     }
 118
 119     Unit->flags = 0;
 120
 121     HostLib_Lock();
 122     err = hdskBase->iface->fstat64(Unit->file, &st);
 123     HostLib_Unlock();
 124
 125     if (err != -1)
 126     {
 127         if (S_ISBLK(st.st_mode))
 128             Unit->flags |= UNIT_DEVICE;
 129     }
 130
 131     D(bug("hostdisk: Unit flags 0x%02X\n", Unit->flags));
 132     return 0;
 133 }
 134
 135 void Host_Close(struct unit *Unit)
 136 {
 137     struct HostDiskBase *hdskBase = Unit->hdskBase;
 138
 139     D(bug("hostdisk: Close device %s\n", Unit->n.ln_Name));
 140     D(bug("hostdisk: HostLibBase 0x%p, close() 0x%p\n", HostLibBase, hdskBase->iface->close));
 141
 142     HostLib_Lock();
 143
 144     hdskBase->iface->close(Unit->file);
 145     AROS_HOST_BARRIER
 146
 147     HostLib_Unlock();
 148 }
 149
 150 LONG Host_Read(struct unit *Unit, APTR buf, ULONG size, ULONG *ioerr)
 151 {
 152     struct HostDiskBase *hdskBase = Unit->hdskBase;
 153     int ret, err;
 154
 155     HostLib_Lock();
 156
 157     ret = hdskBase->iface->read(Unit->file, buf, size);
 158     AROS_HOST_BARRIER
 159     err = *hdskBase->errnoPtr;
 160
 161     HostLib_Unlock();
 162
 163     if (ret == -1)
 164         *ioerr = error(err);
 165
 166     return ret;
 167 }
 168
 169 LONG Host_Write(struct unit *Unit, APTR buf, ULONG size, ULONG *ioerr)
 170 {
 171     struct HostDiskBase *hdskBase = Unit->hdskBase;
 172     int ret, err;
 173
 174     HostLib_Lock();
 175
 176     ret = hdskBase->iface->write(Unit->file, buf, size);
 177     AROS_HOST_BARRIER
 178     err = *hdskBase->errnoPtr;
 179
 180     HostLib_Unlock();
 181
 182     if (ret == -1)
 183         *ioerr = error(err);
 184
 185     return ret;
 186 }
 187
 188 ULONG Host_Seek(struct unit *Unit, ULONG pos)
 189 {
 190     return Host_Seek64(Unit, pos, 0);
 191 }
 192
 193 ULONG Host_Seek64(struct unit *Unit, ULONG pos, ULONG pos_hi)
 194 {
 195     struct HostDiskBase *hdskBase = Unit->hdskBase;
 196     int res;
 197
 198     /*
 199      * Host OS is usually not reentrant.
 200      * All host OS calls should be protected by global lock (since hostlib.resource v3).
 201      */
 202     HostLib_Lock();
 203
 204     res = LSeek(Unit->file, pos, pos_hi, SEEK_SET);
 205     AROS_HOST_BARRIER
 206
 207     HostLib_Unlock();
 208
 209     return (res == -1) ? TDERR_SeekError : 0;
 210 }
 211
 212 ULONG Host_GetGeometry(struct unit *Unit, struct DriveGeometry *dg)
 213 {
 214     struct HostDiskBase *hdskBase = Unit->hdskBase;
 215     int res, err;
 216     struct stat64 st;
 217
 218     if (Unit->flags & UNIT_DEVICE)
 219     {
 220         /* This routine returns UNIX error code, for simplicity */
 221         err = Host_DeviceGeometry(Unit, dg);
 222
 223         /* If this routine is not implemented, use fstat() (worst case) */
 224         if (err != ENOSYS)
 225             return error(err);
 226     }
 227
 228     HostLib_Lock();
 229
 230     res = hdskBase->iface->fstat64(Unit->file, &st);
 231     err = *hdskBase->errnoPtr;
 232
 233     HostLib_Unlock();
 234
 235     D(bug("hostdisk: Image file length: %ld\n", st.st_size));
 236     if (res != -1)
 237     {
 238         dg->dg_TotalSectors = st.st_size / dg->dg_SectorSize;
 239         dg->dg_Cylinders    = dg->dg_TotalSectors; /* LBA, CylSectors == 1 */
 240
 241         return 0;
 242     }
 243
 244     D(bug("hostdisk: Host_GetGeometry(): UNIX error %u\n", err));
 245     return error(err);
 246 }
 247
 248 extern const char Hostdisk_LibName[];
 249
 250 static const char *libcSymbols[] =
 251 {
 252     "open",
 253     "close",
 254     "read",
 255     "write",
 256     "ioctl",
 257     "lseek",
 258 #ifdef HOST_OS_linux
 259     "__errno_location",
 260     "__fxstat64",
 261 #else
 262 #ifdef HOST_OS_android
 263     "__errno",
 264 #else
 265     "__error",
 266 #endif
 267     "fstat64" INODE64_SUFFIX,
 268 #endif
 269     NULL
 270 };
 271
 272 static BOOL CheckArch(const char *Component, const char *MyArch, const char *SystemArch)
 273 {
 274     const char *arg[3] = {Component, MyArch, SystemArch};
 275
 276     D(bug("hostdisk: My architecture: %s, kernel architecture: %s\n", arg[1], arg[2]));
 277
 278     if (strcmp(arg[1], arg[2]))
 279     {
 280         struct IntuitionBase *IntuitionBase;
 281
 282         IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
 283         if (IntuitionBase)
 284         {
 285             struct EasyStruct es =
 286             {
 287                 sizeof (struct EasyStruct),
 288                 0,
 289                 "Incompatible architecture",
 290                 "Used version of %s is built for use\n"
 291                 "with %s architecture, but your\n"
 292                 "system architecture is %s.",
 293                 "Ok",
 294             };
 295
 296             EasyRequestArgs(NULL, &es, NULL, (IPTR *)arg);
 297
 298             CloseLibrary(&IntuitionBase->LibNode);
 299         }
 300         return FALSE;
 301     }
 302
 303     D(bug("hostdisk: Architecture check done\n"));
 304     return TRUE;
 305 }
 306
 307 static int Host_Init(struct HostDiskBase *hdskBase)
 308 {
 309     ULONG r;
 310     STRPTR arch;
 311     /*
 312      * This device is disk-based and it can travel from disk to disk.
 313      * In order to prevent unexplained crashes we check that system architecture
 314      * is the architecture we were built for.
 315      */
 316     APTR KernelBase = OpenResource("kernel.resource");
 317
 318     if (!KernelBase)
 319         return FALSE;
 320
 321     arch = (STRPTR)KrnGetSystemAttr(KATTR_Architecture);
 322     if (!arch)
 323         return FALSE;
 324
 325     if (!CheckArch(Hostdisk_LibName, AROS_ARCHITECTURE, arch))
 326         return FALSE;
 327
 328     hdskBase->KernelHandle = HostLib_Open(LIBC_NAME, NULL);
 329     if (!hdskBase->KernelHandle)
 330         return FALSE;
 331
 332     hdskBase->iface = (struct HostInterface *)HostLib_GetInterface(hdskBase->KernelHandle, libcSymbols, &r);
 333     if ((!hdskBase->iface) || r)
 334         return FALSE;
 335
 336     hdskBase->errnoPtr = hdskBase->iface->__error();
 337
 338     hdskBase->DiskDevice = DISK_DEVICE;
 339     hdskBase->unitBase   = DISK_BASE;
 340
 341     return TRUE;
 342 }
 343
 344 ADD2INITLIB(Host_Init, 0);
 345