DriveMgr.h

Go to the documentation of this file.

/* ========================================
 
  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
 
======================================== */
 
#ifndef INC_DRIVE_MANAGER_H
#define INC_DRIVE_MANAGER_H

 
#include <CompilerKit/CompilerKit.h>
#include <KernelKit/DebugOutput.h>
#include <KernelKit/DeviceMgr.h>
#include <KernelKit/KPC.h>
#include <KernelKit/ProcessScheduler.h>
#include <NeKit/Config.h>
#include <NeKit/KString.h>
#include <NeKit/Ref.h>
 
#define kDriveMaxCount (4U)
#define kDriveSectorSz (512U)
#define kDriveInvalidID (-1)
#define kDriveNameLen (32)
 
#define drv_sector_cnt(SIZE, SECTOR_SZ) (((SIZE) + (SECTOR_SZ)) / (SECTOR_SZ))
 
#define kDriveHiddenPrefix '~'
 
namespace Kernel {
enum {
  kInvalidDrive = -1,

  kBlockDevice      = 0xAD,
  kMassStorageDrive = 0xDA,
  kFloppyDrive      = 0xCD,
  kOpticalDrive     = 0xDC,  // CD-ROM/DVD-ROM/Blu-Ray
  kTapeDrive        = 0xD7,

  kReadOnlyDrive    = 0x10,  // Read only drive
  kEPMDrive         = 0x11,  // Explicit Partition Map.
  kVEPMDrive        = 0x12,  // ESP w/ EPM partition.
  kMBRDrive         = 0x13,  // PC classic partition scheme
  kGPTDrive         = 0x14,  // PC new partition scheme
  kUnformattedDrive = 0x15,
  kStorageCount     = 9,
};

struct DriveTrait final {
  Char   fName[kDriveNameLen] = "/media/null";  // /System, /boot, //./Devices/USB...
  UInt32 fKind{};                               // fMassStorage, fFloppy, fOpticalDrive.
  UInt32 fFlags{};                              // fReadOnly, fEPMDrive...

  struct DrivePacket final {
    VoidPtr fPacketContent{nullptr};             
    Char    fPacketMime[kDriveNameLen] = "*/*";  
    SizeT   fPacketSize{0UL};                    
    UInt32  fPacketCRC32{0UL};                   
    Boolean fPacketGood{YES};
    Lba     fPacketLba{0UL};
    Boolean fPacketReadOnly{NO};
  } fPacket;
 
  Lba   fLbaStart{0}, fLbaEnd{0};
  SizeT fSectorSz{kDriveSectorSz};
 
  Void (*fInput)(DrivePacket& packet){nullptr};
  Void (*fOutput)(DrivePacket& packet){nullptr};
  Void (*fVerify)(DrivePacket& packet){nullptr};
  Void (*fInit)(DrivePacket& packet){nullptr};
  const Char* (*fProtocol)(Void) {nullptr};
};
 
namespace Probe {
  Void io_detect_drive(DriveTrait& trait);
}

typedef DriveTrait* DriveTraitPtr;

class IMountpoint final {
 public:
  explicit IMountpoint() = default;
  ~IMountpoint()         = default;
 
  NE_COPY_DEFAULT(IMountpoint)
 
 public:
  DriveTrait& A() { return mA; }
 
  DriveTrait& B() { return mB; }
 
  DriveTrait& C() { return mC; }
 
  DriveTrait& D() { return mD; }
 
  enum {
    kDriveIndexA = 0,
    kDriveIndexB,
    kDriveIndexC,
    kDriveIndexD,
    kDriveIndexInvalid,
  };
 
  DriveTraitPtr GetAddressOf(const Int32& index) {
    err_local_get() = kErrorSuccess;
 
    switch (index) {
      case kDriveIndexA:
        return &mA;
      case kDriveIndexB:
        return &mB;
      case kDriveIndexC:
        return &mC;
      case kDriveIndexD:
        return &mD;
      default: {
        err_local_get() = kErrorNoSuchDisk;
        kout << "No such disc letter.\n";
 
        break;
      }
    }
 
    return nullptr;
  }
 
 private:
  DriveTrait mA, mB, mC, mD;
};

Void io_drv_unimplemented(DriveTrait::DrivePacket* pckt);

const Char* io_drv_kind(Void);

DriveTrait io_construct_blank_drive(Void);

Void io_construct_main_drive(DriveTrait& trait);

DriveTrait io_construct_main_drive(Void);
 
namespace Detect {
  Void io_detect_drive(DriveTrait& trait);
}
 
Void io_drv_input(DriveTrait::DrivePacket pckt);
 
Void io_drv_output(DriveTrait::DrivePacket pckt);
}  // namespace Kernel
 
#endif /* ifndef INC_DRIVE_MANAGER_H */