MAX_DRIVE, BLOCK_SIZE --> config.h; Check if access is beyond CP/M disk image size.

diff --git a/avr/z180-serv.c b/avr/z180-serv.c
index 87d4b23cf7aaa1277a7d047a611131e557adf6e6..62e8729e2dd24d25e454cb1936c3b8dfcc8fd6ce 100644 (file)
--- a/avr/z180-serv.c
+++ b/avr/z180-serv.c
@@ -1,5 +1,5 @@
 /*
- * (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
+ * (C) Copyright 2014-2016 Leo C. <erbl259-lmu@yahoo.de>
  *
  * SPDX-License-Identifier:    GPL-2.0
  */
@@ -10,6 +10,7 @@
 #include <stdbool.h>
 #include <util/atomic.h>
 
+#include "config.h"
 #include "background.h"
 #include "env.h"
 #include "ff.h"
@@ -206,10 +207,8 @@ void do_msg_get_set_time(uint8_t subf, int len, uint8_t * msg)
 
 /* ---------------------------------------------------------------------------*/
 
-#define MAX_DRIVE      8
-#define BLOCK_SIZE     512
-//#define TPA_BASE     0x10000
-//#define COMMON_BASE  0xC000
+/* TODO: Variable Disk Format */
+#define CONFIG_CPM_DISKSIZE            (8*1024*1024L)
 
 struct cpm_drive_s {
        uint8_t drv;
@@ -219,12 +218,10 @@ struct cpm_drive_s {
        FIL fd;
 };
 
-static uint8_t disk_buffer[BLOCK_SIZE];
-static struct cpm_drive_s drv_table[MAX_DRIVE];
+static uint8_t disk_buffer[CONFIG_CPM_BLOCK_SIZE];
+static struct cpm_drive_s drv_table[CONFIG_CPM_MAX_DRIVE];
 static int handle_cpm_drv_to;
 
-#define f_dirty(fp) ((fp)->fs->wflag != 0)
-
 
 int cpm_drv_to(int state)
 {
@@ -241,8 +238,7 @@ int cpm_drv_to(int state)
 
        case 2:
                if (get_timer(ts) > 1000) {
-                       for (uint_fast8_t i=0; i < MAX_DRIVE; i++) {
-//                             if (&drv_table[i].fd && f_dirty(&drv_table[i].fd)) {
+                       for (uint_fast8_t i=0; i < CONFIG_CPM_MAX_DRIVE; i++) {
                                if (drv_table[i].dirty) {
                                        f_sync(&drv_table[i].fd);
                                        drv_table[i].dirty = false;
@@ -299,7 +295,7 @@ void do_msg_cpm_login(uint8_t subf, int len, uint8_t * msg)
 
 
        drv = msg[0];
-       if ( drv>= MAX_DRIVE) {
+       if ( drv>= CONFIG_CPM_MAX_DRIVE) {
                return msg_cpm_result(subf, 0x02, res);
        }
 
@@ -368,7 +364,7 @@ void do_msg_cpm_rw(uint8_t subf, int len, uint8_t * msg)
        }
 
        drv = msg[ADRV];
-       if ( drv>= MAX_DRIVE) {
+       if ( drv>= CONFIG_CPM_MAX_DRIVE) {
                return msg_cpm_result(subf, 0x02, res);
        }
 
@@ -378,14 +374,21 @@ void do_msg_cpm_rw(uint8_t subf, int len, uint8_t * msg)
 
        /* TODO: tracks per sector from dpb */
        pos = (((uint16_t)(msg[TRK+1] << 8) + msg[TRK]) * 8
-                       + ((uint32_t)(msg[SEC+1] << 8) + msg[SEC])) * BLOCK_SIZE;
+                       + ((uint32_t)(msg[SEC+1] << 8) + msg[SEC])) * CONFIG_CPM_BLOCK_SIZE;
 
        debug_cpmsd("## %7lu cpm_rw: %s %c: trk:%4d, sec: %d, pos: %.8lx, secs: %2d, "
                        "addr: %.5lx\n", get_timer(0), dowrite ? "write" : " read",
                        msg[ADRV]+'A', ((uint16_t)(msg[TRK+1] << 8) + msg[TRK]), msg[SEC],
                        pos, msg[CNT], addr);
 
+       if (pos + secs * CONFIG_CPM_BLOCK_SIZE > CONFIG_CPM_DISKSIZE) {
+               debug_cpmsd("                   access > DISKSIZE (%.8lx > %.8lx) aborted!\n",
+                                               pos + secs * CONFIG_CPM_BLOCK_SIZE, CONFIG_CPM_DISKSIZE);
+               return msg_cpm_result(subf, 0x04, res);
+       }
+
        res = f_lseek(&drv_table[drv].fd, pos);
+
        while (!res && secs--) {
                unsigned int brw;
                if (dowrite) {
@@ -393,30 +396,30 @@ void do_msg_cpm_rw(uint8_t subf, int len, uint8_t * msg)
                                buserr = 1;
                                break;
                        } else {
-                               z80_read_block(disk_buffer, addr, BLOCK_SIZE);
+                               z80_read_block(disk_buffer, addr, CONFIG_CPM_BLOCK_SIZE);
                                z80_bus_cmd(Release);
                        }
-                       res = f_write(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &brw);
+                       res = f_write(&drv_table[drv].fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
                } else {
-                       res = f_read(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &brw);
-                       if (res == FR_OK && brw == BLOCK_SIZE) {
+                       res = f_read(&drv_table[drv].fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
+                       if (res == FR_OK) {
                                if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
                                        buserr = 1;
                                        break;
                                } else {
-                                       z80_write_block(disk_buffer, addr, BLOCK_SIZE);
+                                       z80_write_block(disk_buffer, addr, CONFIG_CPM_BLOCK_SIZE);
                                        z80_bus_cmd(Release);
                                }
                        }
                }
 
-               if (brw != BLOCK_SIZE) {
+               if (brw != CONFIG_CPM_BLOCK_SIZE) {
                        debug_cpmsd("## %7lu f_read res: %d, bytes rd/wr: %u\n", get_timer(0), res, brw);
                        dump_ram(disk_buffer, 0, 64, "Read Data");
                        res = -1;
                }
 
-               addr += BLOCK_SIZE;
+               addr += CONFIG_CPM_BLOCK_SIZE;
        }
 
        if (dowrite && !res) {

diff --git a/include/config.h b/include/config.h
index 9217a5464b308656324bf84fb07dbcf98cfd0be5..71e3dbbde165be48aca178c01951c0541de623c0 100644 (file)
--- a/include/config.h
+++ b/include/config.h
@@ -41,6 +41,9 @@
 //#define CONFIG_CPM3_COMMON_BASE_STR  "F000"
 #define CONFIG_CPM3_BANKED_BASE_STR    "0"
 
+#define CONFIG_CPM_MAX_DRIVE   8
+#define CONFIG_CPM_BLOCK_SIZE  512
+
 #define CONFIG_CMD_MEMTEST
 #define CONFIG_MX_CYCLIC
 #define CONFIG_SYS_RAMSIZE_MAX (1l<<19)        /* max. addressable memory */