haiku.git

/*
 * Copyright (C) 2020 Adrien Destugues <pulkomandy@pulkomandy.tk>
 *
 * Distributed under terms of the MIT license.
 */


#ifdef _BOOT_MODE
#	include <boot/partitions.h>
#else
#	include <DiskDeviceTypes.h>
#endif

#include <ByteOrder.h>
#include <ddm_modules.h>
#include <util/kernel_cpp.h>
#include <KernelExport.h>
#include <stdint.h>
#include <string.h>


//#define TRACE_SUN_PARTITION
#ifdef TRACE_SUN_PARTITION
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif

#define SUN_PARTITION_MODULE_NAME "partitioning_systems/sun/v1"
#define SUN_PARTITION_NAME "Sun volume table of contents"


static uint16_t kMainSignature = 0xDABE;
static uint32_t kVtocSignature = 0x600DDEEE;
static uint32_t kVtocVersion = 1;
static off_t kSectorSize = 512;


struct sun_vtoc {
	char diskName[128];
	struct {
		uint32_t version;
		char volumeName[8];
		uint16_t partitionCount;
		struct {
			uint16_t type;
			uint16_t flags;
		} partitions[8];
		uint8_t bootinfo[12];
		uint8_t reserved[2];
		uint32_t signature;
		uint8_t reserved2[38];
		uint32_t timestamp[8];
	} __attribute__((packed)) vtoc;
	uint16_t write_skip;
	uint16_t read_skip;
	uint8_t reserved[154];
	uint16_t diskSpeed;
	uint16_t cylinders;
	uint16_t alternates;
	uint8_t reserved2[4];
	uint16_t interleave;
	uint16_t dataCylinders;
	uint16_t alternateCylinders;
	uint16_t heads;
	uint16_t sectorsPerTrack;
	uint8_t reserved3[4];
	struct {
		uint32_t startCylinder;
		uint32_t sectorCount;
	} partitions[8];
	uint16_t signature;
	uint16_t checksum;
} __attribute__((packed));


//	#pragma mark -
//	Sun VTOC public module interface


static status_t
sun_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		case B_MODULE_UNINIT:
			return B_OK;
	}

	return B_ERROR;
}


static float
sun_identify_partition(int fd, partition_data *partition, void **_cookie)
{
	uint8 buffer[512];
	ssize_t bytesRead = read_pos(fd, 0, buffer, sizeof(buffer));
	sun_vtoc *vtoc = (sun_vtoc *)buffer;
	if (bytesRead < (ssize_t)sizeof(buffer)) {
		TRACE(("%s: read error: %ld\n", __FUNCTION__, bytesRead));
		return B_ERROR;
	}

	if (vtoc->signature == B_HOST_TO_BENDIAN_INT16(kMainSignature)
		&& vtoc->vtoc.signature == B_HOST_TO_BENDIAN_INT32(kVtocSignature)
		&& vtoc->vtoc.version == B_HOST_TO_BENDIAN_INT32(kVtocVersion)) {
		// TODO verify the checksum

		uint16_t partitionCount
			= B_BENDIAN_TO_HOST_INT16(vtoc->vtoc.partitionCount);
		TRACE(("Found %d partitions\n", partitionCount));

		if (partitionCount > 8)
			return B_ERROR;

		vtoc = new sun_vtoc();
		memcpy(vtoc, buffer, sizeof(sun_vtoc));
		*_cookie = (void *)vtoc;

		bool hasParent = (get_parent_partition(partition->id) != NULL);
		if (!hasParent)
			return 0.61; // Larger than iso9660
		else
			return 0.3;
	}

	return B_ERROR;
}


static status_t
sun_scan_partition(int fd, partition_data *partition, void *cookie)
{
	sun_vtoc *vtoc = (sun_vtoc *)cookie;

	partition->status = B_PARTITION_VALID;
	partition->flags |= B_PARTITION_PARTITIONING_SYSTEM
						| B_PARTITION_READ_ONLY;
	partition->content_size = partition->size;

	off_t headCount = B_BENDIAN_TO_HOST_INT16(vtoc->heads);
	off_t sectorsPerTrack = B_BENDIAN_TO_HOST_INT16(vtoc->sectorsPerTrack);
	off_t cylinderSize = kSectorSize * headCount * sectorsPerTrack;

	TRACE(("%" B_PRIdOFF " heads, %" B_PRIdOFF " sectors, cylindersize %"
		B_PRIdOFF "\n", headCount, sectorsPerTrack, cylinderSize));

	for (int i = 0; i < B_BENDIAN_TO_HOST_INT16(vtoc->vtoc.partitionCount);
		i++) {
		uint16_t type = B_BENDIAN_TO_HOST_INT16(vtoc->vtoc.partitions[i].type);
		// Ignore unused and "whole disk" entries
		if (type == 0 || type == 5)
			continue;

		off_t start = B_BENDIAN_TO_HOST_INT32(
			vtoc->partitions[i].startCylinder) * cylinderSize;
		off_t size = B_BENDIAN_TO_HOST_INT32(vtoc->partitions[i].sectorCount)
			* kSectorSize;
		TRACE(("Part %d type %d start %" B_PRIdOFF " size %" B_PRIdOFF "\n", i,
			type, start, size));
		partition_data *child = create_child_partition(partition->id, i,
			start, size, -1);
		if (child == NULL) {
			TRACE(("sun: Creating child at index %d failed\n", i));
			return B_ERROR;
		}
		child->block_size = partition->block_size;
	}

	return B_OK;
}


static void
sun_free_identify_partition_cookie(partition_data *partition, void *_cookie)
{
	delete (sun_vtoc *)_cookie;
}


#ifndef _BOOT_MODE
static partition_module_info sSunPartitionModule = {
#else
partition_module_info gSunPartitionModule = {
#endif
	{
		SUN_PARTITION_MODULE_NAME,
		0,
		sun_std_ops
	},
	"sun",							// short_name
	SUN_PARTITION_NAME,				// pretty_name
	0,									// flags

	// scanning
	sun_identify_partition,		// identify_partition
	sun_scan_partition,			// scan_partition
	sun_free_identify_partition_cookie,	// free_identify_partition_cookie
	NULL,
//	atari_free_partition_content_cookie,	// free_partition_content_cookie
};

#ifndef _BOOT_MODE
partition_module_info *modules[] = {
	&sSunPartitionModule,
	NULL
};
#endif