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

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