LDFLAGS += -T arch/$(ARCHDIR)/link.ld
OBJ = $(addprefix arch/$(ARCHDIR)/,$(A_OBJ))
-OBJ += heap.o messages.o debug.o modules.o lib.o syscalls.o system.o threads.o
+OBJ += heap.o messages.o debug.o modules.o lib.o syscalls.o system.o threads.o drvutil.o
OBJ += binary.o bin/elf.o
OBJ += vfs/main.o vfs/open.o vfs/acls.o vfs/dir.o vfs/io.o vfs/mount.o vfs/memfile.o vfs/nodecache.o
-OBJ += vfs/fs/root.o vfs/fs/devfs.o vfs/fs/fat.o
-OBJ += drv/dma.o drv/fifo.o drv/pci.o drv/ata_x86.o drv/vterm.o drv/vga.o drv/kb.o drv/fdd.o
+OBJ += vfs/fs/root.o vfs/fs/devfs.o vfs/fs/fat.o vfs/fs/ext2.o
+OBJ += drv/fifo.o drv/dma.o drv/pci.o drv/vterm.o drv/vga.o drv/kb.o
+OBJ += $(addprefix drv/, $(addsuffix .o,$(DRIVERS)))
OBJ := $(addsuffix .$(ARCH), $(OBJ))
BIN = ../Acess2.$(ARCH).bin
include/syscalls.h: syscalls.lst Makefile
php GenSyscalls.php
+Makefile: ../Makefile.cfg arch/$(ARCHDIR)/Makefile
+
# Dependency Files
-include $(DEPFILES)
#define MAX_CALLBACKS_PER_IRQ 4
// === TYPES ===
-typedef void (*tIRQ_Callback)(void);
+typedef void (*tIRQ_Callback)(int);
// === GLOBALS ===
tIRQ_Callback gIRQ_Handlers[16][MAX_CALLBACKS_PER_IRQ];
{
//Log(" IRQ_Handler: Call %p", gIRQ_Handlers[Regs->int_num][i]);
if( gIRQ_Handlers[Regs->int_num][i] )
- gIRQ_Handlers[Regs->int_num][i]();
+ gIRQ_Handlers[Regs->int_num][i](Regs->int_num);
}
- outb(0x20, 0x20); // ACK IRQ
if(Regs->int_num >= 8)
outb(0xA0, 0x20); // ACK IRQ (Secondary PIC)
+ outb(0x20, 0x20); // ACK IRQ
}
/**
- * \fn int IRQ_AddHandler( int Num, void (*Callback)(void) )
+ * \fn int IRQ_AddHandler( int Num, void (*Callback)(int) )
*/
-int IRQ_AddHandler( int Num, void (*Callback)(void) )
+int IRQ_AddHandler( int Num, void (*Callback)(int) )
{
int i;
for( i = 0; i < MAX_CALLBACKS_PER_IRQ; i++ )
extern void MM_Install(tMBoot_Info *MBoot);
extern void MM_InstallVirtual();
extern void Threads_Init();
+extern int Time_Setup();
extern Uint Proc_Clone(Uint *Err, Uint Flags);
extern void Threads_Sleep();
extern void Threads_Exit();
// Start Multitasking
Threads_Init();
+ // Start Timers
+ Time_Setup();
+
Log("Starting VFS...");
// Load Virtual Filesystem
VFS_Init();
giPartMiliseconds -= 0x80000000;
}
+ Log("giTimestamp = %lli", giTimestamp);
+
Timer_CallTimers();
}
i < NUM_TIMERS;
i ++)
{
+ Log("%i", i);
if(gTimers[i].Callback == NULL) continue;
+ Log("%i - %lli < %lli", i, giTimestamp, gTimers[i].FiresAfter);
if(giTimestamp < gTimers[i].FiresAfter) continue;
callback = gTimers[i].Callback;
gTimers[i].Callback = NULL;
int Time_CreateTimer(int Delta, void *Callback, void *Argument)
{
int ret;
+
+ if(Callback == NULL) return -1;
+
for(ret = 0;
ret < NUM_TIMERS;
ret++)
gTimers[ret].Callback = Callback;
gTimers[ret].FiresAfter = giTimestamp + Delta;
gTimers[ret].Argument = Argument;
+ Log("Callback = %p", Callback);
+ Log("Timer %i fires at %lli", ret, gTimers[ret].FiresAfter);
return ret;
}
return -1;
# Acess2 Module/Driver Templater Makefile
# Makefile.tpl
-ARCH = i386
-CC = gcc
-LD = ld
+-include ../../Makefile.cfg
-CPPFLAGS = -I../include -I../arch/$(ARCH)/include -DARCH=$(ARCH) -DBUILD_MODULE
+CPPFLAGS = -I../include -I../arch/$(ARCHDIR)/include -DARCH=$(ARCH) -DBUILD_MODULE
CFLAGS = -Wall -Werror $(CPPFLAGS)
.PHONY: all clean
-all: ata_x86.kmd
+all: bochsvbe.kmd
-%.kmd:
+%.kmd: %.o
$(CC) -shared -nostdlib -o $@ $<
%.o: %.c
$(CC) $(CFLAGS) -o $@ -c $<
-ata_x86.kmd: ata_x86.o
-bochsvbe.kmd: bochsvbe.o
+#ata_x86.kmd: ata_x86.o
+#bochsvbe.kmd: bochsvbe.o
#include <fs_devfs.h>
#include <drv_pci.h>
#include <tpl_drv_common.h>
+#include <drvutil.h>
// === CONSTANTS ===
#define MAX_ATA_DISKS 4
tVFS_Node *ATA_FindDir(tVFS_Node *Node, char *Name);
Uint64 ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
int ATA_IOCtl(tVFS_Node *Node, int Id, void *Data);
- int ATA_Read(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer);
+Uint ATA_Read(Uint64 Address, Uint Count, void *Buffer, Uint Argument);
+ int ATA_ReadRaw(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer);
int ATA_ReadDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer);
-void ATA_IRQHandlerPri(void);
-void ATA_IRQHandlerSec(void);
+void ATA_IRQHandlerPri(int unused);
+void ATA_IRQHandlerSec(int unused);
Uint8 ATA_int_BusMasterReadByte(int Ofs);
void ATA_int_BusMasterWriteByte(int Ofs, Uint8 Value);
void ATA_int_BusMasterWriteDWord(int Ofs, Uint32 Value);
* \fn Uint64 ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
*/
Uint64 ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
-{
- int ret;
- int disk, part;
- Uint64 sector, count;
-
- disk = Node->Inode >> 8;
- part = Node->Inode & 0xFF;
-
- // Aligned Read
- if(Offset % SECTOR_SIZE == 0 && Length % SECTOR_SIZE == 0)
- {
- sector = Offset / SECTOR_SIZE;
- count = Length / SECTOR_SIZE;
- // Raw Disk?
- if(part == 0xFF)
- {
- // Bounds Check
- if( sector >= gATA_Disks[disk].Sectors ) return 0;
- if( sector + count > gATA_Disks[disk].Sectors )
- count = gATA_Disks[disk].Sectors - sector;
- // Read Data
- ret = ATA_Read(disk, sector, count, Buffer);
- }
- else // Or a partition
- {
- //Log(" ATA_ReadFS: %i:%i 0x%llx + 0x%llx\n", disk, part,
- // gATA_Disks[disk].Partitions[part].Start,
- // gATA_Disks[disk].Partitions[part].Length );
-
- // Bounds Check
- if( sector >= gATA_Disks[disk].Partitions[part].Length ) return 0;
- if( sector + count > gATA_Disks[disk].Partitions[part].Length )
- count = gATA_Disks[disk].Partitions[part].Length - sector;
- // Read Disk
- ret = ATA_Read(disk,
- gATA_Disks[disk].Partitions[part].Start + sector,
- count,
- Buffer);
- }
- // Check return value
- if(ret == 1)
- return count * SECTOR_SIZE;
- else {
- Warning("ATA_ReadFS: RETURN 0 (Read failed with ret = %i)", ret);
- return 0;
- }
- }
- Warning("ATA_ReadFS: RETURN 0 (Non-Aligned Read 0x%llx 0x%llx)", Offset, Length);
- return 0;
+{
+ return DrvUtil_ReadBlock(Offset, Length, Buffer, ATA_Read, SECTOR_SIZE, Node->Inode);
}
/**
// --- Disk Access ---
/**
- * \fn int ATA_Read(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer)
+ * \fn Uint ATA_Read(Uint64 Address, Uint Count, void *Buffer, Uint Argument)
+ */
+Uint ATA_Read(Uint64 Address, Uint Count, void *Buffer, Uint Argument)
+{
+ int ret;
+ int disk = Argument >> 8;
+ int part = Argument & 0xFF;
+
+ // Raw Disk Access
+ if(part == 0xFF)
+ {
+ if( Address >= gATA_Disks[disk].Sectors ) return 0;
+ if( Address + Count > gATA_Disks[disk].Sectors )
+ Count = gATA_Disks[disk].Sectors - Address;
+
+ ret = ATA_ReadRaw(disk, Address, Count, Buffer);
+ if(ret == 1)
+ return Count;
+ return 0;
+ }
+
+ if( Address >= gATA_Disks[disk].Partitions[part].Length ) return 0;
+ if( Address + Count > gATA_Disks[disk].Partitions[part].Length )
+ Count = gATA_Disks[disk].Partitions[part].Length - Address;
+
+ ret = ATA_ReadRaw(
+ disk,
+ gATA_Disks[disk].Partitions[part].Start + Address,
+ Count,
+ Buffer);
+
+ if(ret == 1) return Count;
+
+ return 0;
+
+}
+/**
+ * \fn int ATA_ReadRaw(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer)
*/
-int ATA_Read(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer)
+int ATA_ReadRaw(Uint8 Disk, Uint64 Address, Uint64 Count, void *Buffer)
{
int ret;
Uint offset;
Uint16 base;
// Check if the count is small enough
- if(Count > MAX_DMA_SECTORS) return -1;
+ if(Count > MAX_DMA_SECTORS) return 0;
// Get exclusive access to the disk controller
LOCK( &giaATA_ControllerLock[ cont ] );
}
/**
- * \fn void ATA_IRQHandlerPri(void)
+ * \fn void ATA_IRQHandlerPri(int unused)
*/
-void ATA_IRQHandlerPri(void)
+void ATA_IRQHandlerPri(int unused)
{
Uint8 val;
}
/**
- * \fn void ATA_IRQHandlerSec(void)
+ * \fn void ATA_IRQHandlerSec(int unused)
*/
-void ATA_IRQHandlerSec(void)
+void ATA_IRQHandlerSec(int unused)
{
Uint8 val;
// IRQ bit set for Secondary Controller
Uint32 fbSize;\r
} t_bga_mode;\r
\r
-\r
-// === PROTOTYPES ===\r
-// Driver\r
- int BGA_Install(char **Arguments);\r
-void BGA_Uninstall();\r
-// Internal\r
-void BGA_int_WriteRegister(Uint16 reg, Uint16 value);\r
-Uint16 BGA_int_ReadRegister(Uint16 reg);\r
-void BGA_int_SetBank(Uint16 bank);\r
-void BGA_int_SetMode(Uint16 width, Uint16 height, Uint16 bpp);\r
- int BGA_int_UpdateMode(int id);\r
- int BGA_int_FindMode(tVideo_IOCtl_Mode *info);\r
- int BGA_int_ModeInfo(tVideo_IOCtl_Mode *info);\r
- int BGA_int_MapFB(void *Dest);\r
-// Filesystem\r
-Uint64 BGA_Read(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer);\r
-Uint64 BGA_Write(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer);\r
- int BGA_Ioctl(tVFS_Node *node, int id, void *data);\r
-\r
// === CONSTANTS ===\r
-const t_bga_mode BGA_MODES[] = {\r
- {},\r
- {640,480,8, 0, 640*480},\r
- {640,480,32, 0, 640*480*4},\r
- {800,600,8, 0, 800*600},\r
- {800,600,32, 0, 800*600*4},\r
+enum eMode_Flags {\r
+ MODEFLAG_TEXT = 1\r
};\r
-#define BGA_MODE_COUNT (sizeof(BGA_MODES)/sizeof(BGA_MODES[0]))\r
#define BGA_LFB_MAXSIZE (1024*768*4)\r
#define VBE_DISPI_BANK_ADDRESS 0xA0000\r
#define VBE_DISPI_LFB_PHYSICAL_ADDRESS 0xE0000000\r
VBE_DISPI_INDEX_Y_OFFSET\r
};\r
\r
-// GLOBALS\r
+\r
+// === PROTOTYPES ===\r
+// Driver\r
+ int BGA_Install(char **Arguments);\r
+void BGA_Uninstall();\r
+// Internal\r
+void BGA_int_WriteRegister(Uint16 reg, Uint16 value);\r
+Uint16 BGA_int_ReadRegister(Uint16 reg);\r
+void BGA_int_SetBank(Uint16 bank);\r
+void BGA_int_SetMode(Uint16 width, Uint16 height);\r
+ int BGA_int_UpdateMode(int id);\r
+ int BGA_int_FindMode(tVideo_IOCtl_Mode *info);\r
+ int BGA_int_ModeInfo(tVideo_IOCtl_Mode *info);\r
+ int BGA_int_MapFB(void *Dest);\r
+// Filesystem\r
+Uint64 BGA_Read(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer);\r
+Uint64 BGA_Write(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer);\r
+ int BGA_Ioctl(tVFS_Node *node, int id, void *data);\r
+\r
+// === GLOBALS ===\r
MODULE_DEFINE(0, 0x0032, BochsVBE, BGA_Install, NULL, NULL);\r
tDevFS_Driver gBGA_DriverStruct = {\r
NULL, "BochsGA",\r
int giBGA_CurrentMode = -1;\r
int giBGA_DriverId = -1;\r
Uint *gBGA_Framebuffer;\r
+t_bga_mode gBGA_Modes[] = {\r
+ {},\r
+ { 80,25, 32, MODEFLAG_TEXT, 80*25*8}, // 640 x 480\r
+ {100,37, 32, MODEFLAG_TEXT, 100*37*8}, // 800 x 600\r
+ {640,480,8, 0, 640*480},\r
+ {640,480,32, 0, 640*480*4},\r
+ {800,600,8, 0, 800*600},\r
+ {800,600,32, 0, 800*600*4},\r
+};\r
+#define BGA_MODE_COUNT (sizeof(gBGA_Modes)/sizeof(gBGA_Modes[0]))\r
\r
// === CODE ===\r
/**\r
if(giBGA_CurrentMode == -1) return -1;\r
\r
// Check Offset and Length against Framebuffer Size\r
- if(off+len > BGA_MODES[giBGA_CurrentMode].fbSize)\r
+ if(off+len > gBGA_Modes[giBGA_CurrentMode].fbSize)\r
return -1;\r
\r
// Copy from Framebuffer\r
* \brief Write to the framebuffer\r
*/\r
Uint64 BGA_Write(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer)\r
-{\r
- Uint8 *destBuf;\r
- \r
- DEBUGS("BGA_Write: (off=%i, len=0x%x)\n", off, len);\r
+{ \r
+ ENTER("xoff xlen", off, len);\r
\r
// Check Mode\r
- if(giBGA_CurrentMode == -1)\r
+ if(giBGA_CurrentMode == -1) {\r
+ LEAVE('i', -1);\r
return -1;\r
+ }\r
+ \r
// Check Input against Frambuffer Size\r
- if(off+len > BGA_MODES[giBGA_CurrentMode].fbSize)\r
+ if(off+len > gBGA_Modes[giBGA_CurrentMode].fbSize) {\r
+ LEAVE('i', -1);\r
return -1;\r
+ }\r
\r
- destBuf = (Uint8*) ((Uint)gBGA_Framebuffer + (Uint)off);\r
- \r
- DEBUGS(" BGA_Write: *buffer = 0x%x\n", *(Uint*)buffer);\r
- DEBUGS(" BGA_Write: Updating Framebuffer (0x%x - 0x%x bytes)\n", \r
- destBuf, destBuf + (Uint)len);\r
- \r
- \r
- // Copy to Frambuffer\r
- memcpy(destBuf, buffer, len);\r
- \r
- DEBUGS("BGA_Write: BGA Framebuffer updated\n");\r
+ // Text Mode\r
+ if( gBGA_Modes[giBGA_CurrentMode].flags & MODEFLAG_TEXT )\r
+ {\r
+ tVT_Char *chars = buffer;\r
+ int pitch = gBGA_Modes[giBGA_CurrentMode].width * giVT_CharWidth;\r
+ Uint32 *dest;\r
+ dest = (void*)gBGA_Framebuffer;\r
+ dest += off * giVT_CharWidth;\r
+ len /= sizeof(tVT_Char);\r
+ while(len--)\r
+ {\r
+ VT_Font_Render(\r
+ chars->Ch,\r
+ dest, pitch,\r
+ VT_Colour12to24(chars->BGCol),\r
+ VT_Colour12to24(chars->FGCol)\r
+ );\r
+ dest += giVT_CharWidth;\r
+ chars++;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ Uint8 *destBuf = (Uint8*) ((Uint)gBGA_Framebuffer + (Uint)off);\r
+ \r
+ LOG("buffer = %p\n", buffer);\r
+ LOG("Updating Framebuffer (%p to %p)\n", \r
+ destBuf, destBuf + (Uint)len);\r
+ \r
+ \r
+ // Copy to Frambuffer\r
+ memcpy(destBuf, buffer, len);\r
+ \r
+ LOG("BGA Framebuffer updated\n");\r
+ }\r
\r
+ LEAVE('i', len);\r
return len;\r
}\r
\r
* \fn void BGA_int_SetMode(Uint16 width, Uint16 height, Uint16 bpp)\r
* \brief Sets the video mode from the dimensions and bpp given\r
*/\r
-void BGA_int_SetMode(Uint16 width, Uint16 height, Uint16 bpp)\r
+void BGA_int_SetMode(Uint16 width, Uint16 height)\r
{\r
DEBUGS("BGA_int_SetMode: (width=%i, height=%i, bpp=%i)\n", width, height, bpp);\r
BGA_int_WriteRegister(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_DISABLED);\r
BGA_int_WriteRegister(VBE_DISPI_INDEX_XRES, width);\r
BGA_int_WriteRegister(VBE_DISPI_INDEX_YRES, height);\r
- BGA_int_WriteRegister(VBE_DISPI_INDEX_BPP, bpp);\r
+ BGA_int_WriteRegister(VBE_DISPI_INDEX_BPP, 32);\r
BGA_int_WriteRegister(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_ENABLED | VBE_DISPI_NOCLEARMEM | VBE_DISPI_LFB_ENABLED);\r
//BGA_int_WriteRegister(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_ENABLED | VBE_DISPI_NOCLEARMEM);\r
}\r
*/\r
int BGA_int_UpdateMode(int id)\r
{\r
+ // Sanity Check\r
if(id < 0 || id >= BGA_MODE_COUNT) return -1;\r
- BGA_int_SetMode(BGA_MODES[id].width, BGA_MODES[id].height, BGA_MODES[id].bpp);\r
+ \r
+ // Check if it is a text mode\r
+ if( gBGA_Modes[id].flags & MODEFLAG_TEXT )\r
+ BGA_int_SetMode(\r
+ gBGA_Modes[id].width*giVT_CharWidth,\r
+ gBGA_Modes[id].height*giVT_CharHeight);\r
+ else // Graphics?\r
+ BGA_int_SetMode(\r
+ gBGA_Modes[id].width,\r
+ gBGA_Modes[id].height);\r
+ \r
giBGA_CurrentMode = id;\r
return id;\r
}\r
for(i = 0; i < BGA_MODE_COUNT; i++)\r
{\r
#if DEBUG >= 2\r
- LogF("Mode %i (%ix%ix%i), ", i, BGA_MODES[i].width, BGA_MODES[i].height, BGA_MODES[i].bpp);\r
+ LogF("Mode %i (%ix%ix%i), ", i, gBGA_Modes[i].width, gBGA_Modes[i].height, gBGA_Modes[i].bpp);\r
#endif\r
\r
- if(BGA_MODES[i].width == info->width\r
- && BGA_MODES[i].height == info->height\r
- && BGA_MODES[i].bpp == info->bpp)\r
+ if(gBGA_Modes[i].width == info->width\r
+ && gBGA_Modes[i].height == info->height\r
+ && gBGA_Modes[i].bpp == info->bpp)\r
{\r
#if DEBUG >= 2\r
LogF("Perfect!\n");\r
break;\r
}\r
\r
- tmp = BGA_MODES[i].width * BGA_MODES[i].height * BGA_MODES[i].bpp;\r
+ tmp = gBGA_Modes[i].width * gBGA_Modes[i].height * gBGA_Modes[i].bpp;\r
tmp -= rqdProduct;\r
tmp = tmp < 0 ? -tmp : tmp;\r
factor = tmp * 100 / rqdProduct;\r
}\r
}\r
info->id = best;\r
- info->width = BGA_MODES[best].width;\r
- info->height = BGA_MODES[best].height;\r
- info->bpp = BGA_MODES[best].bpp;\r
+ info->width = gBGA_Modes[best].width;\r
+ info->height = gBGA_Modes[best].height;\r
+ info->bpp = gBGA_Modes[best].bpp;\r
return best;\r
}\r
\r
\r
if(info->id < 0 || info->id >= BGA_MODE_COUNT) return -1;\r
\r
- info->width = BGA_MODES[info->id].width;\r
- info->height = BGA_MODES[info->id].height;\r
- info->bpp = BGA_MODES[info->id].bpp;\r
+ info->width = gBGA_Modes[info->id].width;\r
+ info->height = gBGA_Modes[info->id].height;\r
+ info->bpp = gBGA_Modes[info->id].bpp;\r
\r
return 1;\r
}\r
\r
// Sanity Check\r
if((Uint)Dest > 0xC0000000) return 0;\r
- if(BGA_MODES[giBGA_CurrentMode].bpp < 15) return 0; // Only non-pallete modes are supported\r
+ if(gBGA_Modes[giBGA_CurrentMode].bpp < 15) return 0; // Only non-pallete modes are supported\r
\r
// Count required pages\r
- pages = (BGA_MODES[giBGA_CurrentMode].fbSize + 0xFFF) >> 12;\r
+ pages = (gBGA_Modes[giBGA_CurrentMode].fbSize + 0xFFF) >> 12;\r
\r
// Check if there is space\r
for( i = 0; i < pages; i++ )\r
* AcessOS 0.1\r
* Floppy Disk Access Code\r
*/\r
-#define DEBUG 0\r
+#define DEBUG 1\r
#include <common.h>\r
#include <modules.h>\r
#include <fs_devfs.h>\r
static t_floppySector sFDD_SectorCache[CACHE_SIZE];\r
#endif\r
\r
-//=== CODE ===\r
+// === CODE ===\r
/**\r
* \fn char *FDD_ReadDir(tVFS_Node *Node, int pos)\r
* \brief Read Directory\r
int disk;\r
Uint32 buf[128];\r
\r
- ENTER("xoff xlen pbuffer", off, len, buffer)\r
+ ENTER("xoff xlen pbuffer", off, len, buffer);\r
\r
if(node == NULL) {\r
LEAVE('i', -1);\r
}\r
\r
/**\r
- * \fn void fdd_handler(void)\r
+ * \fn void fdd_handler(int unused)\r
* \brief Handles IRQ6\r
*/\r
-void fdd_handler(void)\r
+void fdd_handler(int unused)\r
{\r
fdd_irq6 = 1;\r
}\r
#include <common.h>
#include <modules.h>
#include <fs_devfs.h>
+#include <drv_pci.h>
// === CONSTANTS ===
+#define MEM_START 0x40
+#define MEM_END 0xC0
+#define RX_FIRST (MEM_START)
+#define RX_LAST (MEM_START+RX_BUF_SIZE-1)
+#define RX_BUF_SIZE 0x40
+#define TX_FIRST (MEM_START+RX_BUF_SIZE)
+#define TX_LAST (MEM_END)
+#define TX_BUF_SIZE 0x40
+
static const struct {
Uint16 Vendor;
Uint16 Device;
#define NUM_COMPAT_DEVICES (sizeof(csaCOMPAT_DEVICES)/sizeof(csaCOMPAT_DEVICES[0]))
enum eNe2k_Page0Read {
- COMMAND = 0, //!< the master command register
+ CMD = 0, //!< the master command register
CLDA0, //!< Current Local DMA Address 0
CLDA1, //!< Current Local DMA Address 1
BNRY, //!< Boundary Pointer (for ringbuffer)
};
enum eNe2k_Page0Write {
- PTART = 1, //!< page start (init only)
+ PSTART = 1, //!< page start (init only)
PSTOP, //!< page stop (init only)
TPSR = 4, //!< transmit page start address
TBCR0, //!< transmit byte count (low)
int NextMemPage; //!< Next Card Memory page to use
+ Uint8 Buffer[RX_BUF_SIZE];
+
char Name[2]; // "0"
- tVFS_Node *Node;
- char MacAddr[6];
+ tVFS_Node Node;
+ Uint8 MacAddr[6];
} tCard;
// === PROTOTYPES ===
int Ne2k_Install(char **Arguments);
+char *Ne2k_ReadDir(tVFS_Node *Node, int Pos);
+tVFS_Node *Ne2k_FindDir(tVFS_Node *Node, char *Name);
Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
+Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length);
+void Ne2k_IRQHandler(int IntNum);
// === GLOBALS ===
MODULE_DEFINE(0, 0x0032, Ne2k, Ne2k_Install, NULL, NULL);
NULL, "ne2k",
{
.NumACLs = 1,
- .ACLs = &gVFS_ACL_EveryoneRW,
- .Flags = VFS_FFLAG_DIRECTORY
+ .ACLs = &gVFS_ACL_EveryoneRX,
+ .Flags = VFS_FFLAG_DIRECTORY,
+ .ReadDir = Ne2k_ReadDir,
+ .FindDir = Ne2k_FindDir
}
};
Uint16 gNe2k_BaseAddress;
int giNe2k_CardCount = 0;
+tCard *gpNe2k_Cards = NULL;
// === CODE ===
/**
int Ne2k_Install(char **Options)
{
int i, j, k;
+ int count, id, base;
// --- Scan PCI Bus ---
// Count Cards
base = PCI_AssignPort( id, 0, 0x20 );
gpNe2k_Cards[ k ].IOBase = base;
gpNe2k_Cards[ k ].IRQ = PCI_GetIRQ( id );
- gpNe2k_Cards[ k ].NextMemPage = 1;
+ gpNe2k_Cards[ k ].NextMemPage = 64;
- //Install IRQ6 Handler
- IRQ_Set(gpNe2k_Cards[ k ].IRQ, Ne2k_IRQHandler);
+ // Install IRQ Handler
+ IRQ_AddHandler(gpNe2k_Cards[ k ].IRQ, Ne2k_IRQHandler);
// Reset Card
outb( base + 0x1F, inb(base + 0x1F) );
outb( base + ISR, 0x80 );
// Initialise Card
- outb( base + COMMAND, 0x21 ); // No DMA and Stop
+ outb( base + CMD, 0x21 ); // No DMA and Stop
outb( base + DCR, 0x49 ); // Set WORD mode
outb( base + IMR, 0x00 );
outb( base + ISR, 0xFF );
outb( base + RBCR1, 0 );
outb( base + RSAR0, 0 ); // Clear Source Address
outb( base + RSAR1, 0 );
- outb( base + COMMAND, 0x0A ); // Remote Read, Start
+ outb( base + CMD, 0x0A ); // Remote Read, Start
// Read MAC Address
gpNe2k_Cards[ k ].MacAddr[0] = inb(base+0x10); inb(base+0x10);
gpNe2k_Cards[ k ].MacAddr[4] = inb(base+0x10); inb(base+0x10);
gpNe2k_Cards[ k ].MacAddr[5] = inb(base+0x10); inb(base+0x10);
- outb( base+PSTART, 0x60); // Set Receive Start
- outb( base+BNRY, 0x7F); // Set Boundary Page
- outb( base+PSTOP, 0x80); // Set Stop Page
+ outb( base+PSTART, RX_FIRST); // Set Receive Start
+ outb( base+BNRY, RX_LAST-1); // Set Boundary Page
+ outb( base+PSTOP, RX_LAST); // Set Stop Page
outb( base+ISR, 0xFF ); // Clear all ints
outb( base+CMD, 0x22 ); // No DMA, Start
outb( base+IMR, 0x3F ); // Set Interupt Mask
outb( base+RCR, 0x8F ); // Set WRAP and allow all packet matches
outb( base+TCR, 0x00 ); // Set Normal Transmitter mode
outb( base+TPSR, 0x40); // Set Transmit Start
-
// Set MAC Address
/*
Ne2k_WriteReg(base, MAC0, gpNe2k_Cards[ k ].MacAddr[0]);
Ne2k_WriteReg(base, MAC5, gpNe2k_Cards[ k ].MacAddr[5]);
*/
- Log("[NE2K]: Card #%i: IRQ=%i, Base=0x%x, ",
- k, gpNe2k_Cards[ k ].IRQ, gpNe2k_Cards[ k ].PortBase,
- gpNe2k_Cards[ k ].Buffer);
- Log("MAC Address %x:%x:%x:%x:%x:%x\n",
+ Log("[NE2K]: Card #%i: IRQ=%i, IOBase=0x%x",
+ k, gpNe2k_Cards[ k ].IRQ, gpNe2k_Cards[ k ].IOBase);
+ Log("MAC Address %x:%x:%x:%x:%x:%x",
gpNe2k_Cards[ k ].MacAddr[0], gpNe2k_Cards[ k ].MacAddr[1],
gpNe2k_Cards[ k ].MacAddr[2], gpNe2k_Cards[ k ].MacAddr[3],
gpNe2k_Cards[ k ].MacAddr[4], gpNe2k_Cards[ k ].MacAddr[5]
// Set VFS Node
gpNe2k_Cards[ k ].Name[0] = '0'+k;
gpNe2k_Cards[ k ].Name[1] = '\0';
- gpNe2k_Cards[ k ].Node.NumACLs = 1;
- gpNe2k_Cards[ k ].Node.ACLs = gVFS_ACL_EveryoneRW;
+ gpNe2k_Cards[ k ].Node.ImplPtr = &gpNe2k_Cards[ k ];
+ gpNe2k_Cards[ k ].Node.NumACLs = 0; // Root Only
gpNe2k_Cards[ k ].Node.CTime = now();
gpNe2k_Cards[ k ].Node.Write = Ne2k_Write;
}
}
+ gNe2k_DriverInfo.RootNode.Size = giNe2k_CardCount;
DevFS_AddDevice( &gNe2k_DriverInfo );
return 0;
}
+/**
+ * \fn char *Ne2k_ReadDir(tVFS_Node *Node, int Pos)
+ */
+char *Ne2k_ReadDir(tVFS_Node *Node, int Pos)
+{
+ char ret[2];
+ if(Pos < 0 || Pos >= giNe2k_CardCount) return NULL;
+ ret[0] = '0'+Pos;
+ ret[1] = '\0';
+ return strdup(ret);
+}
+
+/**
+ * \fn tVFS_Node *Ne2k_FindDir(tVFS_Node *Node, char *Name)
+ */
+tVFS_Node *Ne2k_FindDir(tVFS_Node *Node, char *Name)
+{
+ if(Name[0] == '\0' || Name[1] != '\0') return NULL;
+
+ return &gpNe2k_Cards[ Name[0]-'0' ].Node;
+}
/**
* \fn Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
{
tCard *Card = (tCard*)Node->ImplPtr;
+ Uint16 *buf = Buffer;
+ int rem = Length;
// Sanity Check Length
- if(Length > 0xFFFF) return 0;
+ if(Length > TX_BUF_SIZE) return 0;
- outb(Card->IOBase + COMMAND, 0|0x22); // Page 0, Start, NoDMA
+ outb(Card->IOBase + CMD, 0|0x22); // Page 0, Start, NoDMA
// Send Size
- outb(Card->IOBase + RBCR0, Count & 0xFF);
- outb(Card->IOBase + RBCR1, Count >> 8);
+ outb(Card->IOBase + RBCR0, Length & 0xFF);
+ outb(Card->IOBase + RBCR1, Length >> 8);
// Clear Remote DMA Flag
outb(Card->IOBase + ISR, 0x40); // Bit 6
// Set up transfer
outb(Card->IOBase + RSAR0, 0x00); // Page Offset
outb(Card->IOBase + RSAR1, Ne2k_int_GetWritePage(Card, Length)); // Page Offset
+ // Start
+ outb(Card->IOBase + CMD, 0|0x12); // Page 0, Start, DMA
+
+ // Send Data
+ for(rem = Length; rem; rem -= 2)
+ outw(Card->IOBase + 0x10, *buf++);
return 0;
}
*/
Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length)
{
+ Uint8 ret = Card->NextMemPage;
+
+ Card->NextMemPage += (Length + 0xFF) >> 8;
+ if(Card->NextMemPage >= TX_LAST) {
+ Card->NextMemPage -= TX_BUF_SIZE;
+ }
+ return ret;
+}
+
+/**
+ * \fn void Ne2k_IRQHandler(int IntNum)
+ */
+void Ne2k_IRQHandler(int IntNum)
+{
}
# include "vterm_font_8x16.h"
#endif
+// === PROTOTYPES ===
+Uint8 *VT_Font_GetChar(Uint32 Codepoint);
-int VT_Font_GetWidth(Uint32 Codepoint)
-{
- return FONT_WIDTH;
-}
-int VT_Font_GetHeight(Uint32 Codepoint)
+// === GLOBALS ===
+int giVT_CharWidth = FONT_WIDTH;
+int giVT_CharHeight = FONT_HEIGHT;
+
+// === CODE ===
+/**
+ * \fn void VT_Font_Render(Uint32 Codepoint, void *Buffer, int Pitch, Uint32 BGC, Uint32 FGC)
+ * \brief Render a font character
+ */
+void VT_Font_Render(Uint32 Codepoint, void *Buffer, int Pitch, Uint32 BGC, Uint32 FGC)
{
- return FONT_HEIGHT;
+ Uint8 *font;
+ Uint32 *buf = Buffer;
+ int x, y;
+ font = VT_Font_GetChar(Codepoint);
+
+ for(y = 0; y < FONT_HEIGHT; y ++)
+ {
+ for(x = 0; x < FONT_WIDTH; x ++)
+ {
+ if(*font & (1 << (FONT_WIDTH-x)))
+ buf[x] = FGC;
+ else
+ buf[x] = BGC;
+ }
+ buf += Pitch;
+ font ++;
+ }
}
/**
- * \fn void VT_Font_Render(Uint32 Codepoint, void *Buffer, Uint32 BGC, Uint32 FGC)
- * \brief Render a font character
+ * \fn Uint32 VT_Colour12to24(Uint16 Col12)
+ * \brief Converts a
*/
-void VT_Font_Render(Uint32 Codepoint, void *Buffer, Uint32 BGC, Uint32 FGC)
+Uint32 VT_Colour12to24(Uint16 Col12)
{
- //Uint8 *font;
- //Uint32 *buf = Buffer;
- //font = VT_Font_GetChar(Codepoint);
+ Uint32 ret;
+ int tmp;
+ tmp = Col12 & 0xF;
+ ret = (tmp << 0) | (tmp << 4);
+ tmp = (Col12 & 0xF0) >> 4;
+ ret |= (tmp << 8) | (tmp << 12);
+ tmp = (Col12 & 0xF00) >> 8;
+ ret |= (tmp << 16) | (tmp << 20);
+ return ret;
}
/**
return &VTermFont[index*FONT_HEIGHT];
}
+
+EXPORTAS(&giVT_CharWidth, giVT_CharWidth);
+EXPORTAS(&giVT_CharHeight, giVT_CharHeight);
+EXPORT(VT_Font_Render);
+EXPORT(VT_Colour12to24);
// === FUNCTIONS ===
// --- Core ---
extern void System_Init(char *ArgString);
-extern int IRQ_AddHandler(int Num, void (*Callback)(void));
+extern int IRQ_AddHandler(int Num, void (*Callback)(int));
// --- Debug ---
extern void Panic(char *Msg, ...);
extern void Warning(char *Msg, ...);
extern int Threads_GetGID();
extern int SpawnTask(tThreadFunction Function, void *Arg);
extern Uint *Threads_GetCfgPtr(int Id);
+// --- Simple Math ---
+extern int DivUp(int num, int dem);
#include <binary_ext.h>
#include <vfs_ext.h>
extern Uint32 PCI_GetBAR3(int id);\r
extern Uint32 PCI_GetBAR4(int id);\r
extern Uint32 PCI_GetBAR5(int id);\r
+extern Uint16 PCI_AssignPort(int id, int bar, int count);\r
\r
#endif\r
SYS_TELL, // 77 - Return the current file position
SYS_CHDIR, // 78 - Change current directory
SYS_GETCWD, // 79 - Get current directory
+ SYS_MOUNT, // 80 - Mount a filesystem
NUM_SYSCALLS,
SYS_DEBUG = 0x100 // 0x100 - Print a debug string
};
"","","","","SYS_OPEN","SYS_REOPEN",
"SYS_CLOSE","SYS_READ","SYS_WRITE","SYS_IOCTL","SYS_READDIR","SYS_MKDIR",
"SYS_SYMLINK","SYS_GETACL","SYS_SETACL","SYS_FINFO","SYS_SEEK","SYS_TELL",
- "SYS_CHDIR","SYS_GETCWD",""
+ "SYS_CHDIR","SYS_GETCWD","SYS_MOUNT",""
};
#endif
%define SYS_TELL 77 ; Return the current file position
%define SYS_CHDIR 78 ; Change current directory
%define SYS_GETCWD 79 ; Get current directory
+%define SYS_MOUNT 80 ; Mount a filesystem
short id; //!< Mide ID\r
Uint16 width; //!< Width\r
Uint16 height; //!< Height\r
- Uint16 bpp; //!< Bits per Pixel\r
+ Uint8 bpp; //!< Bits per Pixel\r
+ Uint8 flags; //!< Mode Flags\r
};\r
+#define VIDEO_FLAG_TEXT 0x1 //!< Text Mode\r
+#define VIDEO_FLAG_SLOW 0x2 //!< Non-accelerated mode\r
+/**\r
+ */\r
struct sVideo_IOCtl_Pos {\r
Sint16 x;\r
Sint16 y;\r
#define VT_COL_LTGREY 0x0CCC\r
#define VT_COL_WHITE 0x0FFF\r
\r
+extern int giVT_CharWidth;\r
+extern int giVT_CharHeight;\r
+extern void VT_Font_Render(Uint32 Codepoint, void *Buffer, int Pitch, Uint32 BGC, Uint32 FGC);\r
+extern Uint32 VT_Colour12to24(Uint16 Col12);\r
+\r
#endif\r
typedef struct sVFS_Driver {
char *Name;
Uint Flags;
- tVFS_Node *(*InitDevice)(char *Device, char *Options);
+ tVFS_Node *(*InitDevice)(char *Device, char **Options);
void (*Unmount)(tVFS_Node *Node);
struct sVFS_Driver *Next;
} tVFS_Driver;
return ret;
}
+/**
+ * \fn int DivUp(int num, int dem)
+ * \brief Divide two numbers, rounding up
+ * \param num Numerator
+ * \param dem Denominator
+ */
+int DivUp(int num, int dem)
+{
+ return (num+dem-1)/dem;
+}
+
/**
* \fn int strpos8(char *str, Uint32 search)
* \brief Search a string for a UTF-8 character
VFS_Close( Regs->Arg1 );
break;
+ case SYS_SEEK:
+ ret = VFS_Seek( Regs->Arg1, Regs->Arg2, Regs->Arg3);
+ break;
+
+ case SYS_TELL:
+ ret = VFS_Tell( Regs->Arg1 );
+ break;
+
case SYS_WRITE:
#if BITS < 64
ret = VFS_Write( Regs->Arg1, Regs->Arg2|((Uint64)Regs->Arg3<<32), (void*)Regs->Arg4 );
ret = VFS_ChDir( (void*)Regs->Arg1 );
break;
+ // IO Control
+ case SYS_IOCTL:
+ ret = VFS_IOCtl( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
+ break;
+
+ // Mount a filesystem
+ case SYS_MOUNT:
+ // Only root can mount filesystems
+ if(Threads_GetUID() != 0) {
+ err = -EACCES;
+ ret = -1;
+ break;
+ }
+ // Sanity check the paths
+ if(!Syscall_ValidString(Regs->Arg1)
+ || !Syscall_ValidString(Regs->Arg2)
+ || !Syscall_ValidString(Regs->Arg3)
+ || !Syscall_ValidString(Regs->Arg4) ) {
+ err = -EINVAL;
+ ret = -1;
+ break;
+ }
+ ret = VFS_Mount(
+ (char*)Regs->Arg1, // Device
+ (char*)Regs->Arg2, // Mount point
+ (char*)Regs->Arg3, // Filesystem
+ (char*)Regs->Arg4 // Options
+ );
+ break;
+
// -- Debug
case SYS_DEBUG:
Log((char*)Regs->Arg1,
SYS_TELL Return the current file position
SYS_CHDIR Change current directory
SYS_GETCWD Get current directory
+SYS_MOUNT Mount a filesystem
// === PROTOTYPES ===
int DevFS_AddDevice(tDevFS_Driver *Dev);
-tVFS_Node *DevFS_InitDevice(char *Device, char *Options);
+tVFS_Node *DevFS_InitDevice(char *Device, char **Options);
char *DevFS_ReadDir(tVFS_Node *Node, int Pos);
tVFS_Node *DevFS_FindDir(tVFS_Node *Node, char *Name);
}
/**
- * \fn tVFS_Node *DevFS_InitDevice(char *Device, char *Options)
+ * \fn tVFS_Node *DevFS_InitDevice(char *Device, char **Options)
* \brief Initialise the DevFS and detect double-mounting, or just do nothing
* \stub
*/
-tVFS_Node *DevFS_InitDevice(char *Device, char *Options)
+tVFS_Node *DevFS_InitDevice(char *Device, char **Options)
{
return &gDevFS_RootNode;
}
* \brief Second Extended Filesystem Driver\r
* \todo Implement file read support\r
*/\r
+#define DEBUG 1\r
#include <common.h>\r
#include <vfs.h>\r
+#include <modules.h>\r
#include "fs_ext2.h"\r
\r
// === STRUCTURES ===\r
typedef struct {\r
int FD;\r
int CacheID;\r
- vfs_node RootNode;\r
+ tVFS_Node RootNode;\r
\r
tExt2_SuperBlock SuperBlock;\r
int BlockSize;\r
} tExt2_Disk;\r
\r
// === PROTOTYPES ===\r
-//Interface Functions\r
+ int Ext2_Install(char **Arguments);\r
+// Interface Functions\r
tVFS_Node *Ext2_InitDevice(char *Device, char **Options);\r
-void Ext2_UnMount(tVFS_Node *Node);\r
+void Ext2_Unmount(tVFS_Node *Node);\r
Uint64 Ext2_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
Uint64 Ext2_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
+void Ext2_CloseFile(tVFS_Node *Node);\r
char *Ext2_ReadDir(tVFS_Node *Node, int Pos);\r
tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *FileName);\r
-tVFS_Node *Ext2_MkNod(tVFS_Node *Node, char *Name, Uint Flags);\r
- int Ext2_int_GetInode(vfs_node *Node, tExt2_Inode *Inode);\r
-tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeId, char *Name, Uint64 VfsInode);\r
+ int Ext2_MkNod(tVFS_Node *Node, char *Name, Uint Flags);\r
+// Internal Helpers\r
+ int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode);\r
+tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeId, char *Name);\r
int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode);\r
Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum);\r
\r
// === SEMI-GLOBALS ===\r
+MODULE_DEFINE(0, 0x5B /*v0.90*/, EXT2, Ext2_Install, NULL);\r
tExt2_Disk gExt2_disks[6];\r
int giExt2_count = 0;\r
-tVFS_Driver gExt2_FSInfo = {NULL,\r
- "ext2", 0, Ext2_InitDevice, Ext2_UnMount, NULL\r
+tVFS_Driver gExt2_FSInfo = {\r
+ "ext2", 0, Ext2_InitDevice, Ext2_Unmount, NULL\r
};\r
\r
// === CODE ===\r
\r
/**\r
- * \fn void Ext2_Install()\r
+ * \fn int Ext2_Install(char **Arguments)\r
* \brief Install the Ext2 Filesystem Driver\r
*/\r
-void Ext2_Install()\r
+int Ext2_Install(char **Arguments)\r
{\r
VFS_AddDriver( &gExt2_FSInfo );\r
+ return 1;\r
}\r
\r
/**\r
// Open Disk\r
fd = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE); //Open Device\r
if(fd == -1) {\r
- Warning"[EXT2] Unable to open '%s'\n", Device);\r
+ Warning("[EXT2] Unable to open '%s'\n", Device);\r
return NULL;\r
}\r
\r
\r
// Sanity Check Magic value\r
if(sb.s_magic != 0xEF53) {\r
- WarningEx("EXT2", "Volume '%s' is not an EXT2 volume\n", Device);\r
+ Warning("[EXT2 ] Volume '%s' is not an EXT2 volume\n", Device);\r
VFS_Close(fd);\r
return NULL;\r
}\r
\r
// Allocate Disk Information\r
disk = malloc(sizeof(tExt2_Disk) + sizeof(tExt2_Group)*groupCount);\r
- disk->fd = fd;\r
+ disk->FD = fd;\r
memcpy(&disk->SuperBlock, &sb, 1024);\r
disk->GroupCount = groupCount;\r
\r
disk->BlockSize = 1024 << sb.s_log_block_size;\r
\r
// Read Group Information\r
- VFS_ReadAt(disk->fd,\r
+ VFS_ReadAt(disk->FD,\r
sb.s_first_data_block * disk->BlockSize + 1024,\r
sizeof(tExt2_Group)*groupCount,\r
disk->Groups);\r
Ext2_int_ReadInode(disk, 2, &inode);\r
\r
// Create Root Node\r
- memset(&disk->RootNode, 0, sizeof(vfs_node));\r
+ memset(&disk->RootNode, 0, sizeof(tVFS_Node));\r
disk->RootNode.Inode = 2; // Root inode ID\r
disk->RootNode.ImplPtr = disk; // Save disk pointer\r
disk->RootNode.Size = -1; // Fill in later (on readdir)\r
{\r
tExt2_Disk *disk = Node->ImplPtr;\r
\r
- VFS_Close( disk->fd );\r
+ VFS_Close( disk->FD );\r
Inode_ClearCache( disk->CacheID );\r
memset(disk, 0, sizeof(tExt2_Disk)+disk->GroupCount*sizeof(tExt2_Group));\r
free(disk);\r
// Read only block\r
if(Length <= disk->BlockSize - Offset)\r
{\r
- VFS_ReadAt( disk->fd, base+Offset, Length, Buffer);\r
+ VFS_ReadAt( disk->FD, base+Offset, Length, Buffer);\r
return Length;\r
}\r
\r
// Read first block\r
remLen = Length;\r
- VFS_ReadAt( disk->fd, base + Offset, disk->BlockSize - Offset, Buffer);\r
+ VFS_ReadAt( disk->FD, base + Offset, disk->BlockSize - Offset, Buffer);\r
remLen -= disk->BlockSize - Offset;\r
Buffer += disk->BlockSize - Offset;\r
block ++;\r
while(remLen > disk->BlockSize)\r
{\r
base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);\r
- VFS_ReadAt( disk->fd, base, disk->BlockSize, Buffer);\r
+ VFS_ReadAt( disk->FD, base, disk->BlockSize, Buffer);\r
Buffer += disk->BlockSize;\r
remLen -= disk->BlockSize;\r
block ++;\r
\r
// Read last block\r
base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);\r
- VFS_ReadAt( disk->fd, base, remLen, Buffer);\r
+ VFS_ReadAt( disk->FD, base, remLen, Buffer);\r
\r
return Length;\r
}\r
\r
// Write only block (if only one)\r
if(Offset + retLen <= disk->BlockSize) {\r
- VFS_WriteAt(disk->fd, base+Offset, retLen, Buffer);\r
+ VFS_WriteAt(disk->FD, base+Offset, retLen, Buffer);\r
if(bNewBlocks) return Length;\r
goto addBlocks; // Ugh! A goto, but it seems unavoidable\r
}\r
\r
// Write First Block\r
- VFS_WriteAt(disk->fd, base+Offset, disk->BlockSize-Offset, Buffer);\r
+ VFS_WriteAt(disk->FD, base+Offset, disk->BlockSize-Offset, Buffer);\r
Buffer += disk->BlockSize-Offset;\r
retLen -= disk->BlockSize-Offset;\r
block ++;\r
while(retLen > disk->BlockSize)\r
{\r
base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);\r
- VFS_WriteAt(disk->fd, base, disk->BlockSize, Buffer);\r
+ VFS_WriteAt(disk->FD, base, disk->BlockSize, Buffer);\r
Buffer += disk->BlockSize;\r
retLen -= disk->BlockSize;\r
block ++;\r
\r
// Write last block\r
base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);\r
- VFS_WriteAt(disk->fd, base, retLen, Buffer);\r
+ VFS_WriteAt(disk->FD, base, retLen, Buffer);\r
if(bNewBlocks) return Length; // Writing in only allocated space\r
}\r
\r
addBlocks:\r
///\todo Implement block allocation\r
- WarningEx("EXT2", "File extending is not yet supported");\r
+ Warning("[EXT2] File extending is not yet supported");\r
\r
return 0;\r
}\r
\r
/**\r
- * \fn int Ext2_CloseFile(vfs_node *Node)\r
+ * \fn void Ext2_CloseFile(vfs_node *Node)\r
* \brief Close a file (Remove it from the cache)\r
*/\r
-int Ext2_CloseFile(tVFS_Node *Node)\r
+void Ext2_CloseFile(tVFS_Node *Node)\r
{\r
tExt2_Disk *disk = Node->ImplPtr;\r
- inode_uncacheNode(disk->CacheID, Node->impl);\r
- return 1;\r
+ Inode_UncacheNode(disk->CacheID, Node->Inode);\r
+ return ;\r
}\r
\r
/**\r
int block = 0, ofs = 0;\r
int entNum = 0;\r
tExt2_Disk *disk = Node->ImplPtr;\r
- Uint64 vfsInode = 0;\r
- tVFS_Node *retNode;\r
Uint size;\r
\r
ENTER("pNode iPos", Node, Pos);\r
Base = inode.i_block[0] * disk->BlockSize;\r
while(Pos -- && size > 0)\r
{\r
- VFS_ReadAt( disk->fd, Base+ofs, sizeof(tExt2_DirEnt), &dirent);\r
+ VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);\r
ofs += dirent.rec_len;\r
size -= dirent.rec_len;\r
entNum ++;\r
if(ofs >= disk->BlockSize) {\r
block ++;\r
if( ofs > disk->BlockSize ) {\r
- Warning("[EXT2] Directory Entry %i of inode %i ('%s') extends over a block boundary, ignoring\n",\r
- entNum-1, Node->impl, Node->name);\r
+ Warning("[EXT2] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",\r
+ entNum-1, Node->Inode);\r
}\r
ofs = 0;\r
Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );\r
if(size <= 0) return NULL;\r
\r
// Read Entry\r
- VFS_ReadAt( disk->fd, Base+ofs, sizeof(tExt2_DirEnt), &dirent );\r
+ VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent );\r
//LOG(" Ext2_ReadDir: dirent.inode = %i\n", dirent.inode);\r
//LOG(" Ext2_ReadDir: dirent.rec_len = %i\n", dirent.rec_len);\r
//LOG(" Ext2_ReadDir: dirent.name_len = %i\n", dirent.name_len);\r
- VFS_ReadAt( disk->fd, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );\r
+ VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );\r
namebuf[ dirent.name_len ] = '\0'; // Cap off string\r
\r
\r
// Ignore . and .. (these are done in the VFS)\r
if( (namebuf[0] == '.' && namebuf[1] == '\0')\r
- || (namebuf[0] == '.' && namebuf[1] == '.' && namebuf[2]=='\0'))\r
+ || (namebuf[0] == '.' && namebuf[1] == '.' && namebuf[2]=='\0')) {\r
LEAVE('p', VFS_SKIP);\r
return VFS_SKIP; // Skip\r
}\r
// Find File\r
while(size > 0)\r
{\r
- VFS_ReadAt( disk->fd, Base+ofs, sizeof(tExt2_DirEnt), &dirent);\r
- VFS_ReadAt( disk->fd, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );\r
+ VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);\r
+ VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );\r
namebuf[ dirent.name_len ] = '\0'; // Cap off string\r
// If it matches, create a node and return it\r
if(strcmp(namebuf, Filename) == 0)\r
if(ofs >= disk->BlockSize) {\r
block ++;\r
if( ofs > disk->BlockSize ) {\r
- Warnin("[EXT2 ] Directory Entry %i of inode %i ('%s') extends over a block boundary, ignoring\n",\r
- entNum-1, Node->impl, Node->name);\r
+ Warning("[EXT2 ] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",\r
+ entNum-1, Node->Inode);\r
}\r
ofs = 0;\r
Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );\r
}\r
\r
/**\r
- * \fn tVFS_Node *Ext2_MkNod(tVFS_Node *Parent, char *Name, int Flags)\r
+ * \fn int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)\r
* \brief Create a new node\r
*/\r
-tVFS_Node *Ext2_MkNod(tVFS_Node *Parent, char *Name, int Flags)\r
+int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)\r
{\r
return 0;\r
}\r
if( !Ext2_int_ReadInode(Disk, InodeID, &inode) )\r
return NULL;\r
\r
- if( (tmpNode = inode_getCache(Disk->CacheID, InodeID)) )\r
+ if( (tmpNode = Inode_GetCache(Disk->CacheID, InodeID)) )\r
return tmpNode;\r
\r
\r
break;\r
// Regular File\r
case EXT2_S_IFREG:\r
- retNode.flags = 0;\r
+ retNode.Flags = 0;\r
break;\r
// Directory\r
case EXT2_S_IFDIR:\r
- retNode.ReadRir = Ext2_ReadDir;\r
+ retNode.ReadDir = Ext2_ReadDir;\r
retNode.FindDir = Ext2_FindDir;\r
retNode.MkNod = Ext2_MkNod;\r
//retNode.Relink = Ext2_Relink;\r
break;\r
// Unknown, Write protect and hide it to be safe \r
default:\r
- retNode.flags = VFS_FFLAG_READONLY|VFS_FFLAG_HIDDEN;\r
+ retNode.Flags = VFS_FFLAG_READONLY;//|VFS_FFLAG_HIDDEN;\r
break;\r
}\r
\r
// Check if the file should be hidden\r
- if(Name[0] == '.') retNode.Flags |= VFS_FFLAG_HIDDEN;\r
+ //if(Name[0] == '.') retNode.Flags |= VFS_FFLAG_HIDDEN;\r
\r
// Set Timestamps\r
retNode.ATime = now();\r
\r
//LogF(" Ext2_int_ReadInode: group=%i, subId = %i\n", group, subId);\r
\r
- //Seek to Block - Absolute\r
- vfs_seek(Disk->fd, Disk->Groups[group].bg_inode_table * Disk->BlockSize, SEEK_SET);\r
- //Seeek to inode - Relative\r
- vfs_seek(Disk->fd, sizeof(tExt2_Inode)*subId, SEEK_CUR);\r
- vfs_read(Disk->fd, sizeof(tExt2_Inode), Inode);\r
+ // Read Inode\r
+ VFS_ReadAt(Disk->FD,\r
+ Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,\r
+ sizeof(tExt2_Inode),\r
+ Inode);\r
return 1;\r
}\r
\r
\r
// Single Indirect Blocks\r
iBlocks = malloc( Disk->BlockSize );\r
- VFS_ReadAt(Disk->fd, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
\r
BlockNum -= 12;\r
if(BlockNum < 256) {\r
// Double Indirect Blocks\r
if(BlockNum < 256*256)\r
{\r
- VFS_ReadAt(Disk->fd, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
- VFS_ReadAt(Disk->fd, (Uint64)iBlocks[BlockNum/256]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/256]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
BlockNum = iBlocks[BlockNum%256];\r
free(iBlocks);\r
return (Uint64)BlockNum * Disk->BlockSize;\r
}\r
// Triple Indirect Blocks\r
- VFS_ReadAt(Disk->fd, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
- VFS_ReadAt(Disk->fd, (Uint64)iBlocks[BlockNum/(256*256)]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
- VFS_ReadAt(Disk->fd, (Uint64)iBlocks[(BlockNum/256)%256]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/(256*256)]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
+ VFS_ReadAt(Disk->FD, (Uint64)iBlocks[(BlockNum/256)%256]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
BlockNum = iBlocks[BlockNum%256];\r
free(iBlocks);\r
return (Uint64)BlockNum * Disk->BlockSize;\r
\r
// === PROTOTYPES ===\r
int FAT_Install(char **Arguments);\r
-tVFS_Node *FAT_InitDevice(char *device, char *options);\r
+tVFS_Node *FAT_InitDevice(char *device, char **options);\r
void FAT_Unmount(tVFS_Node *Node);\r
Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
Uint64 FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
void FAT_CloseFile(tVFS_Node *node);\r
\r
// === SEMI-GLOBALS ===\r
-MODULE_DEFINE(0, 0x5B /*v0.90*/, FAT32, FAT_Install, NULL);\r
+MODULE_DEFINE(0, 0x51 /*v0.80*/, FAT32, FAT_Install, NULL);\r
tFAT_VolInfo gFAT_Disks[8];\r
int giFAT_PartCount = 0;\r
#if CACHE_FAT\r
}\r
\r
/**\r
- * \fn tVFS_Node *FAT_InitDevice(char *Device, char *options)\r
+ * \fn tVFS_Node *FAT_InitDevice(char *Device, char **options)\r
* \brief Reads the boot sector of a disk and prepares the structures for it\r
*/\r
-tVFS_Node *FAT_InitDevice(char *Device, char *options)\r
+tVFS_Node *FAT_InitDevice(char *Device, char **options)\r
{\r
fat_bootsect *bs;\r
int i;\r
#define MAX_FILES 64
// === PROTOTYPES ===
-tVFS_Node *Root_InitDevice(char *Device, char *Options);
+tVFS_Node *Root_InitDevice(char *Device, char **Options);
int Root_MkNod(tVFS_Node *Node, char *Name, Uint Flags);
tVFS_Node *Root_FindDir(tVFS_Node *Node, char *Name);
char *Root_ReadDir(tVFS_Node *Node, int Pos);
// === CODE ===
/**
- * \fn tVFS_Node *Root_InitDevice(char *Device, char *Options)
+ * \fn tVFS_Node *Root_InitDevice(char *Device, char **Options)
* \brief Initialise the root filesystem
*/
-tVFS_Node *Root_InitDevice(char *Device, char *Options)
+tVFS_Node *Root_InitDevice(char *Device, char **Options)
{
tRamFS_File *root;
if(strcmp(Device, "root") != 0) {
char *VFS_GetTruePath(char *Path)
{
tVFS_Node *node;
- char *ret;
+ char *ret, *tmp;
- node = VFS_ParsePath(Path, &ret);
+ tmp = VFS_GetAbsPath(Path);
+ if(tmp == NULL) return NULL;
+ node = VFS_ParsePath(tmp, &ret);
+ free(tmp);
if(!node) return NULL;
if(node->Close) node->Close(node);
memcpy( mnt->Options, ArgString, argLen+1 );
// Initialise Volume
- mnt->RootNode = fs->InitDevice(Device, ArgString);
+ mnt->RootNode = fs->InitDevice(Device, NULL); //&ArgString);
if(!mnt->RootNode) {
free(mnt);
return -2;
strcpy(ret, cwd);
ret[cwdLen] = '/';
strcpy(&ret[cwdLen+1], Path);
+ //Log("ret = '%s'\n", ret);
}
// Parse Path
ret[iPos2] = 0;
LEAVE('s', ret);
- Log("VFS_GetAbsPath: RETURN '%s'", ret);
+ //Log("VFS_GetAbsPath: RETURN '%s'", ret);
return ret;
}
// Sanity Check
/*if(!longestMount) {
- Log("VFS_GetTruePath - ERROR: No Root Node\n");
+ Log("VFS_ParsePath - ERROR: No Root Node\n");
return NULL;
}*/
free(*TruePath);
*TruePath = NULL;
}
- Log("Permissions fail on '%s'", Path);
+ //Log("Permissions fail on '%s'", Path);
LEAVE('n');
return NULL;
}
*TruePath = NULL;
}
Path[nextSlash] = '/';
- Log("FindDir fail on '%s'", Path);
+ //Log("FindDir fail on '%s'", Path);
LEAVE('n');
return NULL;
}
free(*TruePath);
*TruePath = NULL;
}
- Log("Child fail on '%s' ('%s)", Path, &Path[ofs]);
+ //Log("Child fail on '%s' ('%s)", Path, &Path[ofs]);
Path[nextSlash] = '/';
LEAVE('n');
return NULL;
if( MM_GetPhysAddr( (Uint)gaUserHandles ) == 0 )
{
Uint addr, size;
- Log("Allocating %i user handles", CFGINT(CFG_VFS_MAXFILES));
size = CFGINT(CFG_VFS_MAXFILES) * sizeof(tVFS_Handle);
for(addr = 0; addr < size; addr += 0x1000)
MM_Allocate( (Uint)gaUserHandles + addr );
// Set new
CFGPTR(CFG_VFS_CWD) = buf;
- //Log("Updated CWD to '%s'", buf);
+ Log("Updated CWD to '%s'", buf);
return 1;
}
OBJDUMP = objdump
RM = @rm -f
STRIP = strip
+MKDIR = mkdir
+RMDIR = rm -rf
ARCH = i386
ARCHDIR = x86
+DRIVERS = ata_x86 ne2000
+# fdd
+
DISTROOT = /mnt/AcessHDD/Acess2
+ACESSDIR = /home/hodgeja/Projects/Acess2
void CallCommand(char **Args);\r
void Command_Logout(int argc, char **argv);\r
void Command_Clear(int argc, char **argv);\r
-void Command_Colour(int argc, char **argv);\r
+void Command_Help(int argc, char **argv);\r
void Command_Cd(int argc, char **argv);\r
void Command_Dir(int argc, char **argv);\r
\r
// ==== CONSTANT GLOBALS ====\r
-char *cCOLOUR_NAMES[8] = {"black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"};\r
struct {\r
char *name;\r
void (*fcn)(int argc, char **argv);\r
} cBUILTINS[] = {\r
{"exit", Command_Logout}, {"logout", Command_Logout},\r
- {"colour", Command_Colour}, {"clear", Command_Clear},\r
+ {"help", Command_Help}, {"clear", Command_Clear},\r
{"cd", Command_Cd}, {"dir", Command_Dir}\r
};\r
static char *cDEFAULT_PATH[] = {"/Acess/Bin"};\r
if(saArgs[0]) free(saArgs);\r
if(!bCached) free(sCommandStr);\r
bCached = 0;\r
+ \r
write(_stdout, strlen(gsCurrentDirectory), gsCurrentDirectory);\r
- write(_stdout, 3, "$ ");\r
+ write(_stdout, 2, "$ ");\r
\r
// Read Command line\r
sCommandStr = ReadCommandLine( &length );\r
char *ret;\r
int len, pos, space = 1023;\r
char ch;\r
+ // int scrollbackPos = giLastCommand;\r
\r
// Preset Variables\r
ret = malloc( space+1 );\r
read(_stdin, 1, &ch); // Read control character\r
switch(ch)\r
{\r
- case 'D': if(pos) pos--; break;\r
- case 'C': if(pos<len) pos++; break;\r
+ //case 'D': if(pos) pos--; break;\r
+ //case 'C': if(pos<len) pos++; break;\r
case '[':\r
read(_stdin, 1, &ch); // Read control character\r
switch(ch)\r
{\r
- case 'D': if(pos) pos--; break;\r
- case 'C': if(pos<len) pos++; break;\r
+ #if 0\r
+ case 'A': // Up\r
+ if( scrollbackPos > 0 ) break;\r
+ \r
+ free(ret);\r
+ ret = strdup( gasCommandHistory[--scrollbackPos] );\r
+ \r
+ len = strlen(ret);\r
+ while(pos--) write(_stdout, 3, "\x1B[D");\r
+ while(pos++ < len) write(_stdout, 3, "\x1B[C");\r
+ break;\r
+ case 'B': // Down\r
+ if( scrollbackPos < giLastCommand-1 ) break;\r
+ free(ret);\r
+ ret = strdup( gasCommandHistory[++scrollbackPos] );\r
+ \r
+ len = strlen(ret);\r
+ while(pos--) write(_stdout, 3, "\x1B[D");\r
+ while(pos++ < len) write(_stdout, 3, "\x1B[C");\r
+ break;\r
+ #endif\r
+ case 'D': // Left\r
+ if(pos == 0) break;\r
+ pos --;\r
+ write(_stdout, 3, "\x1B[D");\r
+ break;\r
+ case 'C': // Right\r
+ if(pos == len-1) break;\r
+ pos++;\r
+ write(_stdout, 3, "\x1B[C");\r
+ break;\r
}\r
}\r
continue;\r
}\r
\r
/**\r
- * \fn void Command_Clear(int argc, char **argv)\r
- * \brief Clear the screen\r
+ * \fn void Command_Colour(int argc, char **argv)\r
+ * \brief Displays the help screen\r
*/\r
-void Command_Clear(int argc, char **argv)\r
+void Command_Help(int argc, char **argv)\r
{\r
- write(_stdout, 4, "\x1B[2J"); //Clear Screen\r
+ Print("Acess 2 Command Line Interface\n");\r
+ Print(" By John Hodge (thePowersGang / [TPG])\n");\r
+ Print("\n");\r
+ Print("Builtin Commands:\n");\r
+ Print(" logout: Return to the login prompt\n");\r
+ Print(" exit: Same\n");\r
+ Print(" help: Display this message\n");\r
+ Print(" clear: Clear the screen\n");\r
+ Print(" cd: Change the current directory\n");\r
+ Print(" dir: Print the contents of the current directory\n");\r
+ //Print("\n");\r
+ return;\r
}\r
\r
/**\r
- * \fn void Command_Colour(int argc, char **argv)\r
- * \brief Set the colour of the shell prompt\r
- * \note Conflicts with coloured `dir` display\r
+ * \fn void Command_Clear(int argc, char **argv)\r
+ * \brief Clear the screen\r
*/\r
-void Command_Colour(int argc, char **argv)\r
+void Command_Clear(int argc, char **argv)\r
{\r
- int fg, bg;\r
- char clrStr[6] = "\x1B[37m";\r
- \r
- // Verify Arg Count\r
- if(argc < 2)\r
- {\r
- goto usage;\r
- }\r
- \r
- // Check Colour\r
- for(fg=0;fg<8;fg++)\r
- if(strcmp(cCOLOUR_NAMES[fg], argv[1]) == 0)\r
- break;\r
-\r
- // Foreground a valid colour\r
- if(fg == 8) {\r
- Print("Unknown Colour '");Print(argv[1]);Print("'\n");\r
- goto usage;\r
- }\r
- // Set Foreground\r
- clrStr[3] = '0' + fg;\r
- write(_stdout, 6, clrStr);\r
- \r
- // Need to Set Background?\r
- if(argc > 2)\r
- {\r
- for(bg=0;bg<8;bg++)\r
- if(strcmp(cCOLOUR_NAMES[bg], argv[2]) == 0)\r
- break;\r
- \r
- // Valid colour\r
- if(bg == 8)\r
- {\r
- Print("Unknown Colour '");Print(argv[2]);Print("'\n");\r
- goto usage;\r
- }\r
- \r
- clrStr[2] = '4';\r
- clrStr[3] = '0' + bg;\r
- write(_stdout, 6, clrStr);\r
- }\r
- // Return\r
- return;\r
-\r
- // Function Usage (Requested via a Goto (I know it's ugly))\r
-usage:\r
- Print("Usage: colour <foreground> [<background>]\n");\r
- Print("Valid Colours are ");\r
- for(fg=0;fg<8;fg++)\r
- {\r
- Print(cCOLOUR_NAMES[fg]);\r
- write(_stdout, 3, ", ");\r
- }\r
- write(_stdout, 4, "\b\b\n");\r
- return;\r
+ write(_stdout, 4, "\x1B[2J"); //Clear Screen\r
}\r
\r
/**\r
# General Makefile
-include ../../../Makefile.cfg
+# satisfying 2 deep applications
+if $(ACESSDIR) == "" then
+ -include ../../../../Makefile.cfg
+#endif
+ACESSDIR := $(ACESSDIR)/Usermode
ASFLAGS = -felf
-CPPFLAGS = -I../../include/
+CPPFLAGS = -I$(ACESSDIR)/include/
CFLAGS = -fno-stack-protector $(CPPFLAGS)
-LDFLAGS = -T ../../Libraries/acess.ld -I /Acess/Libs/ld-acess.so -lc
+LDFLAGS = -T $(ACESSDIR)/Libraries/acess.ld -L $(ACESSDIR)/Libraries -I /Acess/Libs/ld-acess.so -lc
}
// Traverse Directory
- while( (tmp = readdir(fd, buf)) )
+ while( (tmp = readdir(fd, buf)) > 0 )
{
// Error check
if(tmp < 0) {
--- /dev/null
+# Project: mount\r
+\r
+-include ../Makefile.cfg\r
+\r
+COBJ = main.o
+BIN = ../mount\r
+\r
+CFLAGS += -Wall -fno-builtin -fno-stack-protector\r
+LDFLAGS += \r
+\r
+.PHONY : all clean\r
+\r
+all: $(BIN)\r
+\r
+$(BIN): $(COBJ)\r
+ @echo --- $(LD) -o $@\r
+ @$(LD) $(LDFLAGS) -o $@ $(COBJ) -Map Map.txt\r
+ objdump -d $(BIN) > $(BIN).dsm\r
+ cp $(BIN) $(DISTROOT)/Bin/\r
+\r
+clean:\r
+ $(RM) $(COBJ) $(BIN)\r
+\r
+$(COBJ): %.o: %.c\r
+ @echo --- GCC -o $@
+ @$(CC) $(CFLAGS) -c $? -o $@
+\r
--- /dev/null
+/*
+ * Acess2 mount command
+ */
+#include <acess/sys.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define MOUNTABLE_FILE "/Acess/Conf/Mountable"
+#define MOUNTED_FILE "/Acess/Conf/Mounted"
+
+// === PROTOTYPES ===
+void ShowUsage();
+ int GetMountDefs(char **spDevice, char **spDir, char **spType, char **spOptions);
+
+// === CODE ===
+/**
+ * \fn int main(int argc, char *argv[])
+ * \brief Entrypoint
+ */
+int main(int argc, char *argv[])
+{
+ int fd;
+ int i;
+ char *arg;
+ char *sType = NULL;
+ char *sDevice = NULL;
+ char *sDir = NULL;
+ char *sOptions = NULL;
+
+ if(argc < 3) {
+ ShowUsage();
+ return EXIT_FAILURE;
+ }
+
+ // Parse Arguments
+ for( i = 1; i < argc; i++ )
+ {
+ arg = argv[i];
+
+ if(arg[0] == '-')
+ {
+ switch(arg[1])
+ {
+ case 't': sType = argv[++i]; break;
+ case '-':
+ //TODO: Long Arguments
+ default:
+ ShowUsage(argv[0]);
+ return EXIT_FAILURE;
+ }
+ continue;
+ }
+
+ if(sDevice == NULL) {
+ sDevice = arg;
+ continue;
+ }
+
+ if(sDir == NULL) {
+ sDir = arg;
+ continue;
+ }
+
+ ShowUsage(argv[0]);
+ return EXIT_FAILURE;
+ }
+
+ // Check if we even got a device/mountpoint
+ if(sDevice == NULL) {
+ ShowUsage(argv[0]);
+ return EXIT_FAILURE;
+ }
+
+ // If no directory was passed (we want to use the mount list)
+ // or we are not root (we need to use the mount list)
+ // Check the mount list
+ if(sDir == NULL || getuid() != 0)
+ {
+ // Check if it is defined in the mounts file
+ if(GetMountDefs(&sDevice, &sDir, &sType, &sOptions) == 0)
+ {
+ if(sDir == NULL)
+ fprintf(stderr, "Unable to find '%s' in '%s'\n",
+ sDevice, MOUNTABLE_FILE
+ );
+ else
+ fprintf(stderr, "You must be root to mount devices or directories not in '%s'\n",
+ MOUNTABLE_FILE
+ );
+ return EXIT_FAILURE;
+ }
+
+ // We need to be root to mount a filesystem, so, let us be elevated!
+ setuid(0); // I hope I have the setuid bit implemented.
+ }
+ else
+ {
+ // Check that we were passed a filesystem type
+ if(sType == NULL) {
+ fprintf(stderr, "Please pass a filesystem type\n");
+ return EXIT_FAILURE;
+ }
+ }
+
+ // Check Device
+ fd = open(sDevice, OPENFLAG_READ);
+ if(fd == -1) {
+ printf("Device '%s' cannot be opened for reading\n", sDevice);
+ return EXIT_FAILURE;
+ }
+ close(fd);
+
+ // Check Mount Point
+ fd = open(sDir, OPENFLAG_EXEC);
+ if(fd == -1) {
+ printf("Directory '%s' does not exist\n", sDir);
+ return EXIT_FAILURE;
+ }
+ close(fd);
+
+ // Replace sOptions with an empty string if it is still NULL
+ if(sOptions == NULL) sOptions = "";
+
+ // Let's Mount!
+ _SysMount(sDevice, sDir, sType, sOptions);
+
+ return 0;
+}
+
+void ShowUsage(char *ProgName)
+{
+ fprintf(stderr, "Usage:\n", ProgName);
+ fprintf(stderr, " %s [-t <type>] <device> <directory>\n");
+ fprintf(stderr, "or %s <device>\n");
+ fprintf(stderr, "or %s <directory>\n");
+}
+
+/**
+ * \fn int GetMountDefs(char **spDevice, char **spDir, char **spType, char **spOptions)
+ * \brief Reads the mountable definitions file and returns the corresponding entry
+ * \param spDevice Pointer to a string (pointer) determining the device (also is the input for this function)
+ * \note STUB
+ */
+int GetMountDefs(char **spDevice, char **spDir, char **spType, char **spOptions)
+{
+ // TODO: Read the mounts file (after deciding what it will be)
+ return 0;
+}
extern int GetSymbolFromBase(Uint base, char *name, Uint *ret);\r
\r
// === Library Functions ===\r
-extern void strcpy(char *dest, char *src);
-extern int strcmp(char *s1, char *s2);\r
-extern int strlen(char *str);\r
+extern char *strcpy(char *dest, const char *src);\r
+extern char *strcat(char *dest, const char *src);
+extern int strcmp(const char *s1, const char *s2);\r
+extern int strlen(const char *str);\r
+extern int file_exists(char *filename);\r
\r
// === System Calls ===\r
extern void SysExit();\r
extern void SysDebugV(char *fmt, ...);\r
extern Uint SysLoadBin(char *path, Uint *entry);\r
extern Uint SysUnloadBin(Uint Base);\r
+extern int open(char *filename, int flags);\r
+extern void close(int fd);\r
// === ELF Loader ===
extern int ElfGetSymbol(Uint Base, char *name, Uint *ret);\r
[global _SysExit]\r
[global _SysLoadBin]\r
[global _SysUnloadBin]\r
+[global _open]\r
+[global _close]\r
\r
; void SysDebugV(char *fmt, va_list Args)\r
_SysDebug:\r
int 0xAC\r
pop ebx\r
ret\r
+\r
+; int close(char *name, int flags)\r
+_open:\r
+ push ebx\r
+ mov eax, SYS_OPEN\r
+ mov ebx, [esp+0x8] ; Filename\r
+ mov ecx, [esp+0xC] ; Flags\r
+ int 0xAC\r
+ pop ebx\r
+ ret\r
+\r
+; void close(int fd)\r
+_close:\r
+ push ebx\r
+ mov eax, SYS_CLOSE\r
+ mov ebx, [esp+0x8] ; File Descriptor\r
+ int 0xAC\r
+ pop ebx\r
+ ret\r
#include "common.h"\r
\r
// === CODE ===\r
-void strcpy(char *dest, char *src)\r
+char *strcpy(char *dest, const char *src)\r
{\r
+ char *ret = dest;\r
while(*src) {\r
*dest = *src;\r
src ++; dest ++;\r
}\r
*dest = '\0';\r
+ return ret;\r
+}\r
+\r
+char *strcat(char *dest, const char *src)\r
+{\r
+ char *ret = dest;\r
+ while(*dest) dest++;\r
+ while(*src) *dest++ = *src++;\r
+ *dest = '\0';\r
+ return ret;\r
}
-
-int strcmp(char *s1, char *s2)
+\r
+/**\r
+ * \fn int strcmp(const char *s1, const char *s2)\r
+ * \brief Compare two strings\r
+ */
+int strcmp(const char *s1, const char *s2)
{
while(*s1 && *s1 == *s2) s1++,s2++;
return *s1-*s2;
}\r
\r
-int strlen(char *str)\r
+/**\r
+ * \fn int strlen(const char *str)\r
+ * \brief \r
+ */\r
+int strlen(const char *str)\r
{\r
int len = 0;\r
while(*str) len++,str++;\r
return len;\r
}
-
+\r
+/**\r
+ * \fn int file_exists(char *filename)\r
+ * \brief Checks if a file exists\r
+ */
+int file_exists(char *filename)\r
+{\r
+ int fd;\r
+ //fd = open(filename, OPENFLAG_READ);\r
+ fd = open(filename, 0);\r
+ if(fd == -1) return 0;\r
+ close(fd);\r
+ return 1;\r
+}\r
# define DEBUGS(v...) \r
#endif\r
\r
+// === CONSTANTS ===\r
+#define MAX_LOADED_LIBRARIES 64\r
+#define MAX_STRINGS_BYTES 4096\r
+#define SYSTEM_LIB_DIR "/Acess/Libs/"\r
+\r
// === PROTOTYPES ===\r
Uint IsFileLoaded(char *file);
int GetSymbolFromBase(Uint base, char *name, Uint *ret);\r
\r
// === GLOABLS ===\r
-#define MAX_LOADED_LIBRARIES 64\r
-#define MAX_STRINGS_BYTES 4096\r
struct {\r
Uint Base;\r
char *Name;\r
//tLoadLib *gpLoadedLibraries = NULL;\r
\r
// === CODE ===\r
-Uint LoadLibrary(char *filename, char *SearchDir, char **envp)\r
+char *FindLibrary(char *DestBuf, char *SoName, char *ExtraSearchDir)\r
+{ \r
+ // -- #1: Executable Specified\r
+ if(ExtraSearchDir)\r
+ {\r
+ strcpy(DestBuf, ExtraSearchDir);\r
+ strcat(DestBuf, "/");\r
+ strcat(DestBuf, SoName);\r
+ if(file_exists(DestBuf)) return DestBuf;\r
+ }\r
+ \r
+ // -- #2: System\r
+ strcpy(DestBuf, SYSTEM_LIB_DIR);\r
+ strcat(DestBuf, SoName);\r
+ if(file_exists(DestBuf)) return DestBuf;\r
+ \r
+ // -- #3: Current Directory\r
+ if(file_exists(SoName)) return SoName;\r
+ \r
+ return NULL;\r
+}\r
+\r
+/**\r
+ */\r
+Uint LoadLibrary(char *SoName, char *SearchDir, char **envp)\r
{\r
- char sTmpName[1024] = "/Acess/Libs/";\r
+ char sTmpName[1024];\r
+ char *filename;\r
Uint iArg;\r
void (*fEntry)(int, int, char *[], char**);\r
\r
DEBUGS("LoadLibrary: (filename='%s', envp=0x%x)\n", filename, envp);\r
\r
// Create Temp Name\r
- strcpy(&sTmpName[12], filename);\r
- DEBUGS(" LoadLibrary: sTmpName='%s'\n", sTmpName);\r
+ filename = FindLibrary(sTmpName, SoName, SearchDir);\r
+ DEBUGS(" LoadLibrary: filename='%s'\n", filename);\r
\r
- if( (iArg = IsFileLoaded(sTmpName)) )\r
+ if( (iArg = IsFileLoaded(filename)) )\r
return iArg;\r
\r
// Load Library\r
- iArg = SysLoadBin(sTmpName, (Uint*)&fEntry);\r
+ iArg = SysLoadBin(filename, (Uint*)&fEntry);\r
if(iArg == 0) {\r
DEBUGS("LoadLibrary: RETURN 0\n");\r
return 0;\r
DEBUGS(" LoadLibrary: iArg=0x%x, iEntry=0x%x\n", iArg, fEntry);\r
\r
// Load Symbols\r
- fEntry = (void*)DoRelocate( iArg, envp, sTmpName );\r
+ fEntry = (void*)DoRelocate( iArg, envp, filename );\r
\r
// Call Entrypoint\r
- DEBUGS(" LoadLibrary: '%s' Entry 0x%x\n", filename, fEntry);\r
+ DEBUGS(" LoadLibrary: '%s' Entry 0x%x\n", SoName, fEntry);\r
fEntry(iArg, 0, NULL, envp);\r
\r
DEBUGS("LoadLibrary: RETURN 1\n");\r
SYSCALL4 read, SYS_READ ; int, int64_t, void*
SYSCALL4 write, SYS_WRITE ; int, int64_t, void*
SYSCALL4 seek, SYS_SEEK ; int, int64_t, int
+SYSCALL1 tell, SYS_TELL ; int
SYSCALL3 finfo, SYS_FINFO ; int, void*, int
SYSCALL2 readdir, SYS_READDIR ; int, char*
SYSCALL2 _SysGetACL, SYS_GETACL ; int, void*
SYSCALL1 chdir, SYS_CHDIR ; char*
+SYSCALL3 ioctl, SYS_IOCTL ; int, int, void*
+SYSCALL4 _SysMount, SYS_MOUNT ; char*, char*, char*, char*
\r
if(fp->Flags) {\r
fflush(fp);\r
- close(fp->FD);\r
- }\r
+ } else\r
+ fp->FD = -1;\r
\r
// Get main mode\r
switch(mode[0])\r
}\r
\r
//Open File\r
- fp->FD = reopen(fp->FD, file, openFlags);\r
+ if(fp->FD != -1)\r
+ fp->FD = reopen(fp->FD, file, openFlags);\r
+ else\r
+ fp->FD = open(file, openFlags);\r
if(fp->FD == -1) {\r
fp->Flags = 0;\r
return NULL;\r
///\todo Implement\r
}\r
\r
+EXPORT long int ftell(FILE *fp)\r
+{\r
+ if(!fp || !fp->FD) return -1;\r
+ \r
+ return tell(fp->FD);\r
+}\r
+\r
+EXPORT int fseek(FILE *fp, long int amt, int whence)\r
+{\r
+ if(!fp || !fp->FD) return -1;\r
+ \r
+ return seek(fp->FD, amt, whence);\r
+}\r
+\r
+\r
/**\r
* \fn EXPORT int vfprintf(FILE *fp, const char *format, va_list args)\r
* \brief Print to a file from a variable argument list\r
}\r
\r
/**\r
+ * \fn EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
+ * \brief Write to a stream\r
*/\r
EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
{\r
return ret;\r
}\r
\r
+/**\r
+ * \fn EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
+ * \brief Read from a stream\r
+ */\r
+EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
+{\r
+ int ret;\r
+ if(!fp || !fp->FD) return -1;\r
+ \r
+ ret = read(fp->FD, size*num, ptr);\r
+ \r
+ return ret;\r
+}\r
+\r
/**\r
* \fn EXPORT int fputc(int c, FILE *fp)\r
* \brief Write a single character to the stream\r
#define LOCAL\r
#endif\r
\r
+extern void *memcpy(void *dest, const void *src, size_t n);\r
+\r
#endif\r
EXPORT void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *))\r
{\r
int i, j, min;\r
+ // With 0 items, there's nothing to do and with 1 its already sorted\r
+ if(nmemb == 0 || nmemb == 1) return;\r
+ \r
+ // SORT!\r
for( i = 0; i < (nmemb-1); i++ )\r
{\r
min = i;\r
# define SEEK_END -1
#endif
#define CLONE_VM 0x10
+#define GETMSG_IGNORE ((void*)-1)
#define FILEFLAG_DIRECTORY 0x10
#define FILEFLAG_SYMLINK 0x20
typedef struct s_sysACL t_sysACL;
// === FUNCTIONS ===
-void _SysDebug(char *str, ...);
+extern void _SysDebug(char *str, ...);
// --- Proc ---
-void _exit(int status) __attribute__((noreturn));
-void sleep();
-void wait(int miliseconds);
- int waittid(int id, int *status);
- int clone(int flags, void *stack);
- int execve(char *path, char **argv, char **envp);
-void setuid(int id);
-void setgid(int id);
+extern void _exit(int status) __attribute__((noreturn));
+extern void sleep();
+extern void yield();
+extern void wait(int miliseconds);
+extern int waittid(int id, int *status);
+extern int clone(int flags, void *stack);
+extern int execve(char *path, char **argv, char **envp);
+extern int gettid();
+extern int getpid();
+
+// --- Permissions ---
+extern int getuid();
+extern int getgid();
+extern void setuid(int id);
+extern void setgid(int id);
+
// --- VFS ---
- int chdir(char *dir);
- int open(char *path, int flags);
- int reopen(int fd, char *path, int flags);
-void close(int fd);
-uint64_t read(int fd, uint64_t length, void *buffer);
-uint64_t write(int fd, uint64_t length, void *buffer);
- int seek(int fd, uint64_t offset, int whence);
- int ioctl(int fd, int id, void *data);
- int finfo(int fd, t_sysFInfo *info, int maxacls);
- int readdir(int fd, char *dest);
- int _SysGetACL(int fd, t_sysACL *dest);
+extern int chdir(char *dir);
+extern int open(char *path, int flags);
+extern int reopen(int fd, char *path, int flags);
+extern void close(int fd);
+extern uint64_t read(int fd, uint64_t length, void *buffer);
+extern uint64_t write(int fd, uint64_t length, void *buffer);
+extern int seek(int fd, uint64_t offset, int whence);
+extern uint64_t tell(int fd);
+extern int ioctl(int fd, int id, void *data);
+extern int finfo(int fd, t_sysFInfo *info, int maxacls);
+extern int readdir(int fd, char *dest);
+extern int _SysGetACL(int fd, t_sysACL *dest);
+extern int _SysMount(char *Device, char *Directory, char *Type, char *Options);
+
+// --- IPC ---
+extern int SysSendMessage(int dest, int length, void *Data);
+extern int SysGetMessage(int *src, void *Data);
// --- MEMORY ---
uint64_t _SysGetPhys(uint vaddr);
#ifndef __STDIO_H\r
#define __STDIO_H
\r
+#include <stdlib.h>\r
#include <stdarg.h>\r
typedef struct sFILE FILE;
extern FILE *freopen(FILE *fp, char *file, char *mode);
extern void fclose(FILE *fp);\r
extern void fflush(FILE *fp);\r
+extern long int ftell(FILE *fp);\r
+extern int fseek(FILE *fp, long int amt, int whence);\r
\r
extern size_t fread(void *buf, size_t size, size_t n, FILE *fp);\r
extern size_t fwrite(void *buf, size_t size, size_t n, FILE *fp);\r
#ifndef __STRING_H
#define __STRING_H
+#include <stdlib.h>
+
// Memory
extern void *memset(void *dest, int val, size_t count);
extern void *memcpy(void *dest, const void *src, size_t count);
git.ucc.asn.au / tpg / acess2.git / commitdiff
UCC git Repository :: git.ucc.asn.au