OS_Develop/FreeDOS
OS_Develop/FreeDOS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BUFFERS tuning and misc bug fixes/cleanups (2024c).

Browse Source 
git-svn-id: https://svn.code.sf.net/p/freedos/svn/kernel/trunk@232 6ac86273-5f31-0410-b378-82cca8765d1b
This commit is contained in:
Bart Oldeman 2001-06-03 14:16:18 +00:00
parent f52e31f5c5
commit 68375764dd
29 changed files with 668 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
docs/history.txt
View File

@ -1,3 +1,20 @@
2001 Jun 2 - Build 2024
-------- Bart Oldeman (bart.oldeman@bristol.ac.uk)
+ Fixes Tom:
* small fixes again.
* one possible cause for data corruption (BFR_VALID) detected
* directories with 'ARCHIVE' attribute could not be deleted
* saved even more bytes (now 20 buffers in HMA :-)
* some issues with pathnames around PARSE_MAX removed
* blanks in filenames weren't proper handled
* there was (at rare circumstances) a buffer overflow
while config.sys parsing.
+ Fixes Bart:
* INT 21 0A - Dos Buffered Input reworked
+ Added tom:
* slighly better buffer handling (search BFR_UNCACHE)
now go more FAT+DIR sectors, less DATA sectors into cache
* dos_mkdir tuned (was ~0.5 sec on 64K cluster partitions)
2001 Apr 29 - Build 2024 2001 Apr 29 - Build 2024
-------- Bart Oldeman (bart.oldeman@bristol.ac.uk) -------- Bart Oldeman (bart.oldeman@bristol.ac.uk)
+ Fixes Bart: + Fixes Bart:
@ -20,6 +37,30 @@
* Default lastdrive should be 5 (E) not 6 (F). * Default lastdrive should be 5 (E) not 6 (F).
* fixed not ignoring whitespace after '=' in config.sys * fixed not ignoring whitespace after '=' in config.sys
* noted INT21/AX=3800 bug for getting the country. Put in a workaround for now. * noted INT21/AX=3800 bug for getting the country. Put in a workaround for now.
2001 Apr 29 - Build 2024
-------- Bart Oldeman (bart.oldeman@bristol.ac.uk)
+ Fixes Bart:
* fixed the "TYPE > FOO.TXT" poor man's editor.
* use "fast console output" (int 29) when applicable.
* moved 5 FILES to DOS DS:00CC and fixed the SFT linked list.
* cleaned up findfirst/findnext for redirected drives.
* moved IO segments to 0x70 as this matches other DOS'es.
Tom:
* more VDISK changes (changed slightly by Bart)
* check for presence of A:/B: (changed by Bart to use the BIOS equipment flag
from INT11 instead of INT13).
* added F5/F8 stepping through config.sys; default SHELL=COMMAND.COM /P/E:256
Use ESC to stop single stepping, F5 to skip remaining config.sys/autoexec.bat.
* new sys: uses INT25/26 instead of the low level INT13 related kernel code from
floppy.asm (see also comments in sys.c) + a few fixes (also boot.asm related)
from Bart.
* Hopefully fixed DateTime Changed + ATTRIB |= ARCHIVE bug.
* Combined clk and blk driver entries as much as possible.
* cleaned up dsk.c and saved more bytes.
Przemyslaw Czerpak:
* Default lastdrive should be 5 (E) not 6 (F).
* fixed not ignoring whitespace after '=' in config.sys
* noted INT21/AX=3800 bug for getting the country. Put in a workaround for now.
2001 Apr 21 - Build 2024 2001 Apr 21 - Build 2024
-------- Bart Oldeman (bart.oldeman@bristol.ac.uk) -------- Bart Oldeman (bart.oldeman@bristol.ac.uk)
+ Fixes Tom: + Fixes Tom:

8
fdkernel.lsm
View File

@ -1,13 +1,13 @@
Begin3 Begin3
Title: The FreeDOS Kernel Title: The FreeDOS Kernel
Version: 1.1.20 Version: 1.1.24
Entered-date: 5 May 2000 Entered-date: 2 Jun 2001
Description: The FreeDOS Kernel. Description: The FreeDOS Kernel.
Keywords: kernel freedos dos msdos Keywords: kernel freedos dos msdos
Author: (developers) Author: (developers)
Maintained-by: jimtabor@infohwy.com Maintained-by: bart.oldeman@bristol.ac.uk
Primary-site: http://freedos.sourceforge.net Primary-site: http://freedos.sourceforge.net
Alternate-site: www.freedos.org Alternate-site: www.dosemu.org/~bart
Original-site: http://www.gcfl.net/pub/FreeDOS/kernel Original-site: http://www.gcfl.net/pub/FreeDOS/kernel
Platforms: dos dosemu Platforms: dos dosemu
Copying-policy: GPL Copying-policy: GPL

4
hdr/buffer.h
View File

@ -34,6 +34,9 @@ static BYTE *buffer_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.2 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.1 2001/04/21 22:32:53 bartoldeman * Revision 1.1 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -68,6 +71,7 @@ struct buffer
#define b_dpbp _b._b_dpbp #define b_dpbp _b._b_dpbp
#define b_huge_blkno _b._b_huge_blkno #define b_huge_blkno _b._b_huge_blkno
#define BFR_UNCACHE 0x80 /* indication, not really used */
#define BFR_DIRTY 0x40 /* buffer modified */ #define BFR_DIRTY 0x40 /* buffer modified */
#define BFR_VALID 0x20 /* buffer contains valid data */ #define BFR_VALID 0x20 /* buffer contains valid data */
#define BFR_DATA 0x08 /* buffer is from data area */ #define BFR_DATA 0x08 /* buffer is from data area */

13
hdr/device.h
View File

@ -35,6 +35,9 @@ static BYTE *device_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.6 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.5 2001/04/15 03:21:50 bartoldeman * Revision 1.5 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -312,19 +315,19 @@ typedef boot super; /* Alias for boot structure */
typedef struct typedef struct
{ {
BYTE r_length; /* Request Header length */ UBYTE r_length; /* Request Header length */
BYTE r_unit; /* Unit Code */ UBYTE r_unit; /* Unit Code */
BYTE r_command; /* Command Code */ UBYTE r_command; /* Command Code */
WORD r_status; /* Status */ WORD r_status; /* Status */
BYTE r_reserved[8]; /* DOS Reserved Area */ BYTE r_reserved[8]; /* DOS Reserved Area */
union union
{ {
struct struct
{ {
BYTE _r_nunits; /* number of units */ UBYTE _r_nunits; /* number of units */
BYTE FAR *_r_endaddr; /* Ending Address */ BYTE FAR *_r_endaddr; /* Ending Address */
bpb *FAR * _r_bpbptr; /* ptr to BPB array */ bpb *FAR * _r_bpbptr; /* ptr to BPB array */
BYTE _r_firstunit; UBYTE _r_firstunit;
} }
_r_init; _r_init;
struct struct

4
hdr/fnode.h
View File

@ -36,6 +36,9 @@ static BYTE *fnode_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.6 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.5 2001/04/29 17:34:40 bartoldeman * Revision 1.5 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -126,3 +129,4 @@ struct f_node
UWORD f_boff; /* the byte in the cluster */ UWORD f_boff; /* the byte in the cluster */
}; };
typedef struct f_node FAR * f_node_ptr;

6
hdr/portab.h
View File

@ -36,6 +36,9 @@ static char *portab_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.9 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.8 2001/04/15 03:21:50 bartoldeman * Revision 1.8 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -195,6 +198,9 @@ typedef int COUNT;
typedef unsigned int UCOUNT; typedef unsigned int UCOUNT;
typedef unsigned long ULONG; typedef unsigned long ULONG;
#define STATIC /* local calls inside module */
#ifdef UNIX #ifdef UNIX
typedef char FAR *ADDRESS; typedef char FAR *ADDRESS;
#else #else

2
hdr/version.h
View File

@ -44,4 +44,4 @@ static BYTE *date_hRcsId = "$Id$";
#define REVISION_MINOR 1 #define REVISION_MINOR 1
#define REVISION_SEQ 24 #define REVISION_SEQ 24
#define BUILD 2024 #define BUILD 2024
#define SUB_BUILD "b" #define SUB_BUILD "c"

85
kernel/blockio.c
View File

@ -37,6 +37,9 @@ static BYTE *blockioRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.10 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.9 2001/04/21 22:32:53 bartoldeman * Revision 1.9 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -242,6 +245,11 @@ VOID setblkno(struct buffer FAR * bp, ULONG blkno)
the buffer is not found the buffer is not found
*Buffp contains a block to flush and reuse later *Buffp contains a block to flush and reuse later
new:
upper layer may set UNCACHE attribute
UNCACHE buffers are recycled first.
intended to be used for full sector reads into application buffer
*/ */
BOOL searchblock(ULONG blkno, COUNT dsk, BOOL searchblock(ULONG blkno, COUNT dsk,
@ -251,6 +259,7 @@ BOOL searchblock(ULONG blkno, COUNT dsk,
struct buffer FAR *bp; struct buffer FAR *bp;
struct buffer FAR *lbp = NULL; struct buffer FAR *lbp = NULL;
struct buffer FAR *lastNonFat = NULL; struct buffer FAR *lastNonFat = NULL;
struct buffer FAR *uncacheBuf = NULL;
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
@ -281,6 +290,10 @@ BOOL searchblock(ULONG blkno, COUNT dsk,
return TRUE; return TRUE;
} }
if (bp->b_flag & BFR_UNCACHE)
uncacheBuf = bp;
if (bp->b_flag & BFR_FAT) if (bp->b_flag & BFR_FAT)
fat_count++; fat_count++;
else else
@ -292,10 +305,19 @@ BOOL searchblock(ULONG blkno, COUNT dsk,
or, if we are low on FAT buffers, the last non FAT buffer or, if we are low on FAT buffers, the last non FAT buffer
*/ */
if (uncacheBuf)
{
lbp = uncacheBuf;
}
else
{
if (lbp ->b_flag & BFR_FAT && fat_count < 3 && lastNonFat) if (lbp ->b_flag & BFR_FAT && fat_count < 3 && lastNonFat)
{ {
lbp = lastNonFat; lbp = lastNonFat;
} }
}
lbp->b_flag &= ~BFR_UNCACHE; /* reset uncache attribute */
*pBuffp = lbp; *pBuffp = lbp;
@ -304,6 +326,7 @@ BOOL searchblock(ULONG blkno, COUNT dsk,
#endif #endif
if (lbp != firstbuf) /* move to front */ if (lbp != firstbuf) /* move to front */
{ {
for (bp = firstbuf; bp->b_next != lbp; bp = bp->b_next) for (bp = firstbuf; bp->b_next != lbp; bp = bp->b_next)
@ -316,6 +339,23 @@ BOOL searchblock(ULONG blkno, COUNT dsk,
return FALSE; return FALSE;
} }
void dumpBufferCache(void)
{
struct buffer FAR *bp;
int printed = 0;
/* Search through buffers to see if the required block */
/* is already in a buffer */
for (bp = firstbuf; bp != NULL;bp = bp->b_next)
{
printf("%8lx %02x ",getblkno(bp),bp->b_flag);
if (++printed % 6 == 0)
printf("\n");
}
printf("\n");
}
/* */ /* */
/* Return the address of a buffer structure containing the */ /* Return the address of a buffer structure containing the */
@ -364,17 +404,10 @@ struct buffer FAR *getblock(ULONG blkno, COUNT dsk)
} }
/* /*
Return the address of a buffer structure for the exactly the same as getblock(), but the data will be completely
requested block. This is for writing new data to a block, so overwritten. so there is no need to read from disk first
we really don't care what is in the buffer now.
returns:
TRUE = buffer available, flushed if necessary
parameter is filled with pointer to buffer
FALSE = there was an error flushing the buffer.
parameter is set to NULL
*/ */
BOOL getbuf(struct buffer FAR ** pbp, ULONG blkno, COUNT dsk) struct buffer FAR * getblockOver(ULONG blkno, COUNT dsk)
{ {
struct buffer FAR *bp; struct buffer FAR *bp;
@ -383,8 +416,7 @@ BOOL getbuf(struct buffer FAR ** pbp, ULONG blkno, COUNT dsk)
if (searchblock(blkno, dsk, &bp)) if (searchblock(blkno, dsk, &bp))
{ {
*pbp = bp; return bp;
return TRUE;
} }
/* The block we need is not in a buffer, we must make a buffer */ /* The block we need is not in a buffer, we must make a buffer */
@ -396,14 +428,12 @@ BOOL getbuf(struct buffer FAR ** pbp, ULONG blkno, COUNT dsk)
bp->b_flag = 0; bp->b_flag = 0;
bp->b_unit = dsk; bp->b_unit = dsk;
setblkno(bp, blkno); setblkno(bp, blkno);
*pbp = bp; return bp;
return TRUE;
} }
else else
/* failure */ /* failure */
{ {
*pbp = NULL; return NULL;
return FALSE;
} }
} }
/* */ /* */
@ -472,9 +502,10 @@ BOOL flush1(struct buffer FAR * bp)
} }
} }
else else
result = TRUE; /* This negates any error code returned in result...BER */ result = 0; /* This negates any error code returned in result...BER */
/* and 0 returned, if no errors occurred - tom */
bp->b_flag &= ~BFR_DIRTY; /* even if error, mark not dirty */ bp->b_flag &= ~BFR_DIRTY; /* even if error, mark not dirty */
if (!result) /* otherwise system has trouble */ if (result != 0) /* otherwise system has trouble */
bp->b_flag &= ~BFR_VALID; /* continuing. */ bp->b_flag &= ~BFR_VALID; /* continuing. */
return (TRUE); /* Forced to TRUE...was like this before dskxfer() */ return (TRUE); /* Forced to TRUE...was like this before dskxfer() */
/* returned error codes...BER */ /* returned error codes...BER */
@ -521,6 +552,24 @@ UWORD dskxfer(COUNT dsk, ULONG blkno, VOID FAR * buf, UWORD numblocks, COUNT mod
REG struct dpb FAR *dpbp = CDSp->cds_table[dsk].cdsDpb; REG struct dpb FAR *dpbp = CDSp->cds_table[dsk].cdsDpb;
if ((UCOUNT)dsk >= lastdrive ||
!(CDSp->cds_table[dsk].cdsFlags & CDSPHYSDRV))
{
return -1; /* illegal command */
}
#if 1
#define KeyboardShiftState() (*(BYTE FAR *)(MK_FP(0x40,0x17)))
if (KeyboardShiftState() & 0x01)
{
printf("dskxfer:%s %x - %lx %u\n", mode == DSKWRITE ? "write" : "read", dsk, blkno, numblocks);
if ((KeyboardShiftState() & 0x03) == 3)
dumpBufferCache();
}
#endif
for (;;) for (;;)
{ {
IoReqHdr.r_length = sizeof(request); IoReqHdr.r_length = sizeof(request);

14
kernel/chario.c
View File

@ -36,6 +36,9 @@ static BYTE *charioRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.9 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.8 2001/04/29 17:34:40 bartoldeman * Revision 1.8 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -285,7 +288,7 @@ VOID KbdFlush(void)
static VOID kbfill(keyboard FAR * kp, UCOUNT c, BOOL ctlf, UWORD * vp) static VOID kbfill(keyboard FAR * kp, UCOUNT c, BOOL ctlf, UWORD * vp)
{ {
if (kp->kb_count > kp->kb_size) if (kp->kb_count >= kp->kb_size)
{ {
cso(BELL); cso(BELL);
return; return;
@ -349,8 +352,6 @@ UCOUNT sti(keyboard FAR * kp)
for (i = kp->kb_count; local_buffer[i] != '\0'; i++) for (i = kp->kb_count; local_buffer[i] != '\0'; i++)
{ {
c = local_buffer[kp->kb_count]; c = local_buffer[kp->kb_count];
if (c == '\r' || c == '\n')
break;
kbfill(kp, c, FALSE, &virt_pos); kbfill(kp, c, FALSE, &virt_pos);
} }
break; break;
@ -358,8 +359,6 @@ UCOUNT sti(keyboard FAR * kp)
case RIGHT: case RIGHT:
c = local_buffer[kp->kb_count]; c = local_buffer[kp->kb_count];
if (c == '\r' || c == '\n')
break;
kbfill(kp, c, FALSE, &virt_pos); kbfill(kp, c, FALSE, &virt_pos);
break; break;
} }
@ -397,21 +396,18 @@ UCOUNT sti(keyboard FAR * kp)
break; break;
case CR: case CR:
kbfill(kp, CR, TRUE, &virt_pos);
kbfill(kp, LF, TRUE, &virt_pos);
#ifndef NOSPCL #ifndef NOSPCL
fbcopy((BYTE FAR *) kp->kb_buf, fbcopy((BYTE FAR *) kp->kb_buf,
(BYTE FAR *) local_buffer, (COUNT) kp->kb_count); (BYTE FAR *) local_buffer, (COUNT) kp->kb_count);
local_buffer[kp->kb_count] = '\0'; local_buffer[kp->kb_count] = '\0';
#endif #endif
kbfill(kp, CR, TRUE, &virt_pos);
if (eof) if (eof)
return eof; return eof;
else else
return kp->kb_count; return kp->kb_count;
case LF: case LF:
cso(CR);
cso(LF);
break; break;
case ESC: case ESC:

134
kernel/config.c
View File

@ -80,6 +80,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.23 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.22 2001/04/29 17:34:40 bartoldeman * Revision 1.22 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -590,9 +593,7 @@ INIT VOID configDone(VOID)
INIT VOID DoConfig(VOID) INIT VOID DoConfig(VOID)
{ {
COUNT nFileDesc; COUNT nFileDesc;
COUNT nRetCode; BYTE *pLine;
BYTE *pLine,
*pTmp;
BOOL bEof; BOOL bEof;
/* Check to see if we have a config.sys file. If not, just */ /* Check to see if we have a config.sys file. If not, just */
@ -627,43 +628,69 @@ INIT VOID DoConfig(VOID)
/* Read each line into the buffer and then parse the line, */ /* Read each line into the buffer and then parse the line, */
/* do the table lookup and execute the handler for that */ /* do the table lookup and execute the handler for that */
/* function. */ /* function. */
while (!bEof)
for (;!bEof;nCfgLine++)
{ {
struct table *pEntry; struct table *pEntry;
UWORD bytesLeft = 0;
if (pLine > szLine) pLineStart = szLine;
bytesLeft = LINESIZE - (pLine - szLine);
if (bytesLeft) /* read in a single line, \n or ^Z terminated */
for (pLine = szLine;;)
{ {
fbcopy(pLine, szLine, LINESIZE - bytesLeft); if (read(nFileDesc, pLine, 1) <= 0)
pLine = szLine + bytesLeft; {
bEof = TRUE;
break;
}
if (pLine >= szLine + sizeof(szLine)-3)
{
CfgFailure(pLine);
printf("error - line overflow line %d \n",nCfgLine);
break;
} }
/* Read a line from config */ if (*pLine == '\n' ||
/* Interrupt processing if read error or no bytes read */ *pLine == EOF ) /* end of line */
if ((nRetCode = read(nFileDesc, pLine, LINESIZE - bytesLeft)) <= 0)
break; break;
/* If the buffer was not filled completely, append a if (*pLine == '\r') /* ignore */
CTRL-Z character to mark where the file ends */ ;
else
pLine++;
}
if (nRetCode + bytesLeft < LINESIZE) *pLine = 0;
szLine[nRetCode + bytesLeft] = EOF;
/* Process the buffer, line by line */
pLine = szLine; pLine = szLine;
while (!bEof && *pLine != EOF)
{
/* /* Skip leading white space and get verb. */
Do it here in the loop. pLine = scan(pLine, szBuf);
*/
/* shouldn't this go also AFTER the last line has been read? /* If the line was blank, skip it. Otherwise, look up */
might be the UMB driver */ /* the verb and execute the appropriate function. */
if (*szBuf == '\0')
continue;
pEntry = LookUp(commands, szBuf);
if (pEntry->pass >= 0 && pEntry->pass != nPass)
continue;
if ( SkipLine(pLineStart)) /* F5/F8 processing */
continue;
pLine = skipwh(pLine);
if ('=' != *pLine)
CfgFailure(pLine);
else /* YES. DO IT */
(*(pEntry->func)) (skipwh(pLine+1));
/* might have been the UMB driver */
if(UmbState == 2){ if(UmbState == 2){
if(!Umb_Test()){ if(!Umb_Test()){
UmbState = 1; UmbState = 1;
@ -676,47 +703,6 @@ INIT VOID DoConfig(VOID)
} }
} }
for (pTmp = pLine; pTmp - szLine < LINESIZE; pTmp++)
{
if (*pTmp == '\r' || *pTmp == EOF)
break;
}
if (pTmp - szLine >= LINESIZE)
break;
if (*pTmp == EOF)
bEof = TRUE;
*pTmp = '\0';
pLineStart = pLine;
/* Skip leading white space and get verb. */
pLine = scan(pLine, szBuf);
/* If the line was blank, skip it. Otherwise, look up */
/* the verb and execute the appropriate function. */
if (*szBuf != '\0')
{
pEntry = LookUp(commands, szBuf);
if (pEntry->pass < 0 || pEntry->pass == nPass)
{
if ( !SkipLine(pLineStart))
{
pLine = skipwh(pLine);
if ('=' != *pLine)
CfgFailure(pLine);
else
(*(pEntry->func)) (skipwh(pLine+1));
}
}
}
nCfgLine++;
pLine += strlen(pLine) + 1;
}
} }
close(nFileDesc); close(nFileDesc);
} }
@ -825,7 +811,7 @@ INIT BOOL SkipLine(char *pLine)
{ {
case 'N': case 'N':
case 'n': case 'n':
printf("N"); printf("N\n");
return TRUE; return TRUE;
case 0x1b: /* don't know where documented case 0x1b: /* don't know where documented
@ -838,14 +824,14 @@ INIT BOOL SkipLine(char *pLine)
case '\n': case '\n':
case 'Y': case 'Y':
case 'y': case 'y':
printf("Y"); printf("Y\n");
return FALSE; return FALSE;
} }
if (key == 0x3f00) /* YES, you may hit F5 here, too */ if (key == 0x3f00) /* YES, you may hit F5 here, too */
{ {
printf("N"); printf("N\n");
SkipAllConfig = TRUE; SkipAllConfig = TRUE;
return TRUE; return TRUE;
} }
@ -969,7 +955,7 @@ INIT static VOID Lastdrive(BYTE * pLine)
*/ */
INIT static VOID Dosmem(BYTE * pLine) INIT STATIC VOID Dosmem(BYTE * pLine)
{ {
BYTE *pTmp; BYTE *pTmp;
BYTE UMBwanted = FALSE, HMAwanted = FALSE; BYTE UMBwanted = FALSE, HMAwanted = FALSE;
@ -1515,7 +1501,11 @@ VOID config_init_buffers(COUNT anzBuffers)
int HMAcount = 0; int HMAcount = 0;
anzBuffers = max(anzBuffers,6); anzBuffers = max(anzBuffers,6);
anzBuffers = min(anzBuffers,64); if (anzBuffers > 99)
{
printf("BUFFERS=%u not supported, reducing to 99\n",anzBuffers);
anzBuffers = 99;
}
firstbuf = ConfigAlloc(sizeof (struct buffer)); firstbuf = ConfigAlloc(sizeof (struct buffer));

48
kernel/dosfns.c
View File

@ -37,6 +37,9 @@ static BYTE *dosfnsRcsId = "$Id$";
* /// Added SHARE support. 2000/09/04 Ron Cemer * /// Added SHARE support. 2000/09/04 Ron Cemer
* *
* $Log$ * $Log$
* Revision 1.18 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.17 2001/04/29 17:34:40 bartoldeman * Revision 1.17 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -173,12 +176,12 @@ static BYTE *dosfnsRcsId = "$Id$";
#include "globals.h" #include "globals.h"
sft FAR *get_sft(COUNT); sft FAR *get_sft(UCOUNT);
WORD get_free_hndl(VOID); WORD get_free_hndl(VOID);
sft FAR *get_free_sft(WORD FAR *); sft FAR *get_free_sft(WORD FAR *);
BOOL cmatch(COUNT, COUNT, COUNT); BOOL cmatch(COUNT, COUNT, COUNT);
struct f_node FAR *xlt_fd(COUNT); f_node_ptr xlt_fd(COUNT);
/* /// Added for SHARE. - Ron Cemer */ /* /// Added for SHARE. - Ron Cemer */
@ -248,7 +251,7 @@ static VOID DosGetFile(BYTE FAR * lpszPath, BYTE FAR * lpszDosFileName)
fbcopy((BYTE FAR *) szLclExt, &lpszDosFileName[FNAME_SIZE], FEXT_SIZE); fbcopy((BYTE FAR *) szLclExt, &lpszDosFileName[FNAME_SIZE], FEXT_SIZE);
} }
sft FAR *get_sft(COUNT hndl) sft FAR *get_sft(UCOUNT hndl)
{ {
psp FAR *p = MK_FP(cu_psp, 0); psp FAR *p = MK_FP(cu_psp, 0);
WORD sys_idx; WORD sys_idx;
@ -363,6 +366,11 @@ UCOUNT GenericRead(COUNT hndl, UCOUNT n, BYTE FAR * bp, COUNT FAR * err,
ReadCount = sti((keyboard FAR *) & kb_buf); ReadCount = sti((keyboard FAR *) & kb_buf);
if (ReadCount < kb_buf.kb_count) if (ReadCount < kb_buf.kb_count)
s->sft_flags &= ~SFT_FEOF; s->sft_flags &= ~SFT_FEOF;
else if (kb_buf.kb_count < kb_buf.kb_size) {
kb_buf.kb_buf[kb_buf.kb_count++] = LF;
cso(LF);
ReadCount++;
}
fbcopy((BYTE FAR *) kb_buf.kb_buf, bp, kb_buf.kb_count); fbcopy((BYTE FAR *) kb_buf.kb_buf, bp, kb_buf.kb_count);
*err = SUCCESS; *err = SUCCESS;
return ReadCount; return ReadCount;
@ -683,7 +691,7 @@ COUNT DosSeek(COUNT hndl, LONG new_pos, COUNT mode, ULONG * set_pos)
return result; return result;
} }
static WORD get_free_hndl(void) STATIC WORD get_free_hndl(void)
{ {
psp FAR *p = MK_FP(cu_psp, 0); psp FAR *p = MK_FP(cu_psp, 0);
WORD hndl; WORD hndl;
@ -1023,7 +1031,7 @@ COUNT DosOpen(BYTE FAR * fname, COUNT mode)
if (sftp->sft_status >= 0) if (sftp->sft_status >= 0)
{ {
struct f_node FAR *fnp = xlt_fd(sftp->sft_status); f_node_ptr fnp = xlt_fd(sftp->sft_status);
sftp->sft_attrib = fnp->f_dir.dir_attrib; sftp->sft_attrib = fnp->f_dir.dir_attrib;
@ -1214,7 +1222,7 @@ COUNT DosChangeDir(BYTE FAR * s)
Some redirectors do not write back to the CDS. Some redirectors do not write back to the CDS.
SHSUCdX needs this. jt SHSUCdX needs this. jt
*/ */
fscopy(&PriPathName[0], cdsp->cdsCurrentPath); fstrncpy(cdsp->cdsCurrentPath,&PriPathName[0],sizeof(cdsp->cdsCurrentPath)-1);
if (PriPathName[7] == 0) if (PriPathName[7] == 0)
cdsp->cdsCurrentPath[8] = 0; /* Need two Zeros at the end */ cdsp->cdsCurrentPath[8] = 0; /* Need two Zeros at the end */
@ -1224,7 +1232,7 @@ COUNT DosChangeDir(BYTE FAR * s)
result = dos_cd(cdsp, PriPathName); result = dos_cd(cdsp, PriPathName);
} }
if (result == SUCCESS) { if (result == SUCCESS) {
fscopy(&PriPathName[0], cdsp->cdsCurrentPath); fstrncpy(cdsp->cdsCurrentPath,&PriPathName[0],sizeof(cdsp->cdsCurrentPath)-1);
} }
return result; return result;
} }
@ -1411,8 +1419,28 @@ COUNT DosGetFattr(BYTE FAR * name, UWORD FAR * attrp)
or cleanup, such as converting "c:\a\b\.\c\.." to "C:\A\B". or cleanup, such as converting "c:\a\b\.\c\.." to "C:\A\B".
- Ron Cemer - Ron Cemer
*/ */
/*
memcpy(SecPathName,PriPathName,sizeof(SecPathName)); memcpy(SecPathName,PriPathName,sizeof(SecPathName));
return dos_getfattr(SecPathName, attrp); return dos_getfattr(SecPathName, attrp);
*/
/* no longer true. dos_getfattr() is
A) intelligent (uses dos_open) anyway
B) there are some problems with MAX_PARSE, i.e. if PATH ~= 64
and TRUENAME adds a C:, which leeds to trouble.
the problem was discovered, when VC did something like
fd = DosOpen(filename,...)
jc can't_copy_dialog;
attr = DosGetAttrib(filename);
jc can't_copy_dialog;
and suddenly, the filehandle stays open
shit.
tom
*/
return dos_getfattr(name, attrp);
} }
} }
@ -1449,8 +1477,14 @@ COUNT DosSetFattr(BYTE FAR * name, UWORD FAR * attrp)
to get trashed somewhere in transit. to get trashed somewhere in transit.
- Ron Cemer - Ron Cemer
*/ */
/*
memcpy(SecPathName,PriPathName,sizeof(SecPathName)); memcpy(SecPathName,PriPathName,sizeof(SecPathName));
return dos_setfattr(SecPathName, attrp); return dos_setfattr(SecPathName, attrp);
see DosGetAttr()
*/
return dos_setfattr(name, attrp);
} }
} }

6
kernel/dosnames.c
View File

@ -36,6 +36,9 @@ static BYTE *dosnamesRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.9 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.8 2001/04/15 03:21:50 bartoldeman * Revision 1.8 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -421,8 +424,9 @@ VOID DosTrimPath(BYTE FAR * lpszPathNamep)
lpszRoot = lpszNext + 1; lpszRoot = lpszNext + 1;
} }
/* NAMEMAX + 2, must include C: TE*/
for (lpszLast = lpszNext = lpszPathNamep, nChars = 0; for (lpszLast = lpszNext = lpszPathNamep, nChars = 0;
*lpszNext != '\0' && nChars < NAMEMAX;) *lpszNext != '\0' && nChars < NAMEMAX+2;)
{ {
/* Initialize flag for loop. */ /* Initialize flag for loop. */
flDotDot = FALSE; flDotDot = FALSE;

9
kernel/error.c
View File

@ -34,6 +34,9 @@ static BYTE *errorRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.5 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.4 2001/04/15 03:21:50 bartoldeman * Revision 1.4 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -87,6 +90,7 @@ static BYTE *errorRcsId = "$Id$";
#include "globals.h" #include "globals.h"
#ifdef DEBUG
/* error registers */ /* error registers */
VOID dump(void) VOID dump(void)
{ {
@ -105,6 +109,7 @@ VOID dump(void)
error_regs.DS, error_regs.DS,
error_regs.ES); error_regs.ES);
} }
#endif
/* issue a panic message for corrupted data structures */ /* issue a panic message for corrupted data structures */
VOID panic(BYTE * s) VOID panic(BYTE * s)
@ -124,8 +129,8 @@ VOID fatal(BYTE * err_msg)
/* issue an internal error message */ /* issue an internal error message */
VOID fatal(BYTE * err_msg) VOID fatal(BYTE * err_msg)
{ {
printf("\nInternal kernel error - %s\nSystem halted\n", err_msg); printf("\nInternal kernel error - \n");
for (;;) ; panic(err_msg);
} }
#endif #endif

96
kernel/fatdir.c
View File

@ -36,6 +36,9 @@ static BYTE *fatdirRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.16 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.15 2001/04/29 17:34:40 bartoldeman * Revision 1.15 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -169,11 +172,11 @@ static BYTE *fatdirRcsId = "$Id$";
* Initial revision. * Initial revision.
*/ */
VOID pop_dmp(dmatch FAR *, struct f_node FAR *); VOID pop_dmp(dmatch FAR *, f_node_ptr);
struct f_node FAR *dir_open(BYTE FAR * dirname) f_node_ptr dir_open(BYTE FAR * dirname)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
COUNT drive; COUNT drive;
BYTE *p; BYTE *p;
WORD i; WORD i;
@ -183,9 +186,9 @@ struct f_node FAR *dir_open(BYTE FAR * dirname)
BYTE *pszPath = &TempCDS.cdsCurrentPath[2]; BYTE *pszPath = &TempCDS.cdsCurrentPath[2];
/* Allocate an fnode if possible - error return (0) if not. */ /* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (struct f_node FAR *)0) if ((fnp = get_f_node()) == (f_node_ptr)0)
{ {
return (struct f_node FAR *)NULL; return (f_node_ptr)0;
} }
/* Force the fnode into read-write mode */ /* Force the fnode into read-write mode */
@ -255,7 +258,7 @@ struct f_node FAR *dir_open(BYTE FAR * dirname)
if (media_check(TempCDS.cdsDpb) < 0) if (media_check(TempCDS.cdsDpb) < 0)
{ {
release_f_node(fnp); release_f_node(fnp);
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
fnp->f_dsize = DIRENT_SIZE * TempCDS.cdsDpb->dpb_dirents; fnp->f_dsize = DIRENT_SIZE * TempCDS.cdsDpb->dpb_dirents;
@ -329,7 +332,7 @@ struct f_node FAR *dir_open(BYTE FAR * dirname)
{ {
release_f_node(fnp); release_f_node(fnp);
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
else else
{ {
@ -354,7 +357,7 @@ struct f_node FAR *dir_open(BYTE FAR * dirname)
return fnp; return fnp;
} }
COUNT dir_read(REG struct f_node FAR * fnp) COUNT dir_read(REG f_node_ptr fnp)
{ {
/* REG i; */ /* REG i; */
/* REG j; */ /* REG j; */
@ -396,7 +399,7 @@ COUNT dir_read(REG struct f_node FAR * fnp)
+ fnp->f_dpb->dpb_dirstrt), + fnp->f_dpb->dpb_dirstrt),
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
bp->b_flag &= ~(BFR_DATA | BFR_FAT); bp->b_flag &= ~(BFR_DATA | BFR_FAT);
bp->b_flag |= BFR_DIR; bp->b_flag |= BFR_DIR | BFR_VALID;
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("DIR (dir_read)\n"); printf("DIR (dir_read)\n");
#endif #endif
@ -447,7 +450,7 @@ COUNT dir_read(REG struct f_node FAR * fnp)
+ fnp->f_sector, + fnp->f_sector,
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
bp->b_flag &= ~(BFR_DATA | BFR_FAT); bp->b_flag &= ~(BFR_DATA | BFR_FAT);
bp->b_flag |= BFR_DIR; bp->b_flag |= BFR_DIR | BFR_VALID;
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("DIR (dir_read)\n"); printf("DIR (dir_read)\n");
#endif #endif
@ -478,7 +481,7 @@ COUNT dir_read(REG struct f_node FAR * fnp)
} }
#ifndef IPL #ifndef IPL
COUNT dir_write(REG struct f_node FAR * fnp) COUNT dir_write(REG f_node_ptr fnp)
{ {
struct buffer FAR *bp; struct buffer FAR *bp;
@ -494,7 +497,7 @@ COUNT dir_write(REG struct f_node FAR * fnp)
+ fnp->f_dpb->dpb_dirstrt), + fnp->f_dpb->dpb_dirstrt),
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
bp->b_flag &= ~(BFR_DATA | BFR_FAT); bp->b_flag &= ~(BFR_DATA | BFR_FAT);
bp->b_flag |= BFR_DIR; bp->b_flag |= BFR_DIR | BFR_VALID;
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("DIR (dir_write)\n"); printf("DIR (dir_write)\n");
#endif #endif
@ -546,7 +549,7 @@ COUNT dir_write(REG struct f_node FAR * fnp)
+ fnp->f_sector, + fnp->f_sector,
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
bp->b_flag &= ~(BFR_DATA | BFR_FAT); bp->b_flag &= ~(BFR_DATA | BFR_FAT);
bp->b_flag |= BFR_DIR; bp->b_flag |= BFR_DIR | BFR_VALID;
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("DIR (dir_write)\n"); printf("DIR (dir_write)\n");
#endif #endif
@ -561,13 +564,13 @@ COUNT dir_write(REG struct f_node FAR * fnp)
} }
putdirent((struct dirent FAR *)&fnp->f_dir, putdirent((struct dirent FAR *)&fnp->f_dir,
(VOID FAR *) & bp->b_buffer[(UWORD)fnp->f_diroff % fnp->f_dpb->dpb_secsize]); (VOID FAR *) & bp->b_buffer[(UWORD)fnp->f_diroff % fnp->f_dpb->dpb_secsize]);
bp->b_flag |= BFR_DIRTY; bp->b_flag |= BFR_DIRTY | BFR_VALID;
} }
return DIRENT_SIZE; return DIRENT_SIZE;
} }
#endif #endif
VOID dir_close(REG struct f_node FAR * fnp) VOID dir_close(REG f_node_ptr fnp)
{ {
REG COUNT disk = fnp->f_dpb->dpb_unit; REG COUNT disk = fnp->f_dpb->dpb_unit;
@ -590,7 +593,7 @@ VOID dir_close(REG struct f_node FAR * fnp)
#ifndef IPL #ifndef IPL
COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name) COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
REG dmatch FAR *dmp = (dmatch FAR *) dta; REG dmatch FAR *dmp = (dmatch FAR *) dta;
REG COUNT i; REG COUNT i;
COUNT nDrive; COUNT nDrive;
@ -729,11 +732,11 @@ COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name)
COUNT dos_findnext(void) COUNT dos_findnext(void)
{ {
REG dmatch FAR *dmp = (dmatch FAR *) dta; REG dmatch FAR *dmp = (dmatch FAR *) dta;
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
BOOL found = FALSE; BOOL found = FALSE;
/* Allocate an fnode if possible - error return (0) if not. */ /* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (struct f_node FAR *)0) if ((fnp = get_f_node()) == (f_node_ptr)0)
{ {
return DE_NFILES; return DE_NFILES;
} }
@ -804,7 +807,7 @@ COUNT dos_findnext(void)
return found ? SUCCESS : DE_NFILES; return found ? SUCCESS : DE_NFILES;
} }
static VOID pop_dmp(dmatch FAR * dmp, struct f_node FAR * fnp) static VOID pop_dmp(dmatch FAR * dmp, f_node_ptr fnp)
{ {
dmp->dm_attr_fnd = fnp->f_dir.dir_attrib; dmp->dm_attr_fnd = fnp->f_dir.dir_attrib;
@ -824,6 +827,11 @@ static VOID pop_dmp(dmatch FAR * dmp, struct f_node FAR * fnp)
/* /*
this receives a name in 11 char field NAME+EXT and builds this receives a name in 11 char field NAME+EXT and builds
a zeroterminated string a zeroterminated string
unfortunately, blanks are allowed in filenames. like
"test e", " test .y z",...
so we have to work from the last blank backward
*/ */
void ConvertName83ToNameSZ(BYTE FAR *destSZ, BYTE FAR *srcFCBName) void ConvertName83ToNameSZ(BYTE FAR *destSZ, BYTE FAR *srcFCBName)
{ {
@ -836,23 +844,55 @@ void ConvertName83ToNameSZ(BYTE FAR *destSZ, BYTE FAR *srcFCBName)
} }
for (loop = FNAME_SIZE; --loop >= 0; srcFCBName++)
fmemcpy(destSZ,srcFCBName,FNAME_SIZE);
srcFCBName += FNAME_SIZE;
for (loop = FNAME_SIZE; --loop >= 0; )
{ {
if (*srcFCBName != ' ') if (destSZ[loop] != ' ')
*destSZ++ = *srcFCBName; break;
} }
destSZ += loop + 1;
if (!noExtension) /* not for ".", ".." */ if (!noExtension) /* not for ".", ".." */
{ {
if (*srcFCBName != ' ')
for (loop = FEXT_SIZE; --loop >= 0; )
{
if (srcFCBName[loop] != ' ')
break;
}
if (loop >= 0)
{ {
*destSZ++ = '.'; *destSZ++ = '.';
for (loop = FEXT_SIZE; --loop >= 0; srcFCBName++) fmemcpy(destSZ,srcFCBName,loop+1);
{ destSZ += loop+1;
if (*srcFCBName != ' ')
*destSZ++ = *srcFCBName;
}
} }
} }
*destSZ = '\0'; *destSZ = '\0';
} }
/*
returns the asciiSZ length of a 8.3 filename
*/
int FileName83Length(BYTE *filename83)
{
BYTE buff[13];
ConvertName83ToNameSZ(buff, filename83);
return strlen(buff);
}

258
kernel/fatfs.c
View File

@ -35,7 +35,13 @@ BYTE *RcsId = "$Id$";
#endif #endif
/* /*
* the dos_mkdir/extenddir (with getblock() instead of getblockOver) was a real
* performance killer on large drives. (~0.5 sec /dos_mkdir) TE
*
* $Log$ * $Log$
* Revision 1.18 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.17 2001/04/29 17:34:40 bartoldeman * Revision 1.17 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -225,26 +231,26 @@ BYTE *RcsId = "$Id$";
/* */ /* */
/* function prototypes */ /* function prototypes */
/* */ /* */
struct f_node FAR *xlt_fd(COUNT); f_node_ptrxlt_fd(COUNT);
COUNT xlt_fnp(struct f_node FAR *); COUNT xlt_fnp(f_node_ptr);
struct f_node FAR *split_path(BYTE FAR *, BYTE *, BYTE *, BYTE *); f_node_ptr split_path(BYTE FAR *, BYTE *, BYTE *, BYTE *);
BOOL find_fname(struct f_node FAR *, BYTE *, BYTE *); BOOL find_fname(f_node_ptr, BYTE *, BYTE *);
/* /// Added - Ron Cemer */ /* /// Added - Ron Cemer */
static void merge_file_changes(struct f_node FAR *fnp, int collect); STATIC void merge_file_changes(f_node_ptr fnp, int collect);
/* /// Added - Ron Cemer */ /* /// Added - Ron Cemer */
static int is_same_file(struct f_node FAR *fnp1, struct f_node FAR *fnp2); STATIC int is_same_file(f_node_ptr fnp1, f_node_ptr fnp2);
/* /// Added - Ron Cemer */ /* /// Added - Ron Cemer */
static void copy_file_changes(struct f_node FAR *src, struct f_node FAR *dst); STATIC void copy_file_changes(f_node_ptr src, f_node_ptr dst);
date dos_getdate(VOID); date dos_getdate(VOID);
time dos_gettime(VOID); time dos_gettime(VOID);
BOOL find_free(struct f_node FAR *); BOOL find_free(f_node_ptr);
UWORD find_fat_free(struct f_node FAR *); UWORD find_fat_free(f_node_ptr);
VOID wipe_out(struct f_node FAR *); VOID wipe_out(f_node_ptr);
BOOL last_link(struct f_node FAR *); BOOL last_link(f_node_ptr);
BOOL extend(struct f_node FAR *); BOOL extend(f_node_ptr);
COUNT extend_dir(struct f_node FAR *); COUNT extend_dir(f_node_ptr);
BOOL first_fat(struct f_node FAR *); BOOL first_fat(f_node_ptr);
COUNT map_cluster(struct f_node FAR *, COUNT); COUNT map_cluster(f_node_ptr, COUNT);
/************************************************************************/ /************************************************************************/
/* */ /* */
@ -258,7 +264,7 @@ COUNT map_cluster(struct f_node FAR *, COUNT);
COUNT dos_open(BYTE FAR * path, COUNT flag) COUNT dos_open(BYTE FAR * path, COUNT flag)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
/* First test the flag to see if the user has passed a valid */ /* First test the flag to see if the user has passed a valid */
/* file mode... */ /* file mode... */
@ -331,7 +337,7 @@ BOOL fcmp_wild(BYTE FAR * s1, BYTE FAR * s2, COUNT n)
COUNT dos_close(COUNT fd) COUNT dos_close(COUNT fd)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into a useful pointer */ /* Translate the fd into a useful pointer */
fnp = xlt_fd(fd); fnp = xlt_fd(fd);
@ -339,7 +345,7 @@ COUNT dos_close(COUNT fd)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return DE_INVLDHNDL; return DE_INVLDHNDL;
if (fnp->f_mode != RDONLY) if (fnp->f_mode != RDONLY)
@ -365,17 +371,17 @@ COUNT dos_close(COUNT fd)
/* */ /* */
/* split a path into it's component directory and file name */ /* split a path into it's component directory and file name */
/* */ /* */
struct f_node FAR * f_node_ptr
split_path(BYTE FAR * path, BYTE * dname, BYTE * fname, BYTE * fext) split_path(BYTE FAR * path, BYTE * dname, BYTE * fname, BYTE * fext)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
COUNT nDrive; COUNT nDrive;
struct cds FAR *cdsp; struct cds FAR *cdsp;
/* Start off by parsing out the components. */ /* Start off by parsing out the components. */
if (ParseDosName(adjust_far(path), &nDrive, &dname[2], fname, fext, FALSE) if (ParseDosName(adjust_far(path), &nDrive, &dname[2], fname, fext, FALSE)
!= SUCCESS) != SUCCESS)
return (struct f_node FAR *)0; return (f_node_ptr)0;
if (nDrive < 0) if (nDrive < 0)
nDrive = default_drive; nDrive = default_drive;
@ -387,7 +393,7 @@ struct f_node FAR *
SpacePad(fext, FEXT_SIZE); SpacePad(fext, FEXT_SIZE);
if (nDrive >= lastdrive) { if (nDrive >= lastdrive) {
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
cdsp = &CDSp->cds_table[nDrive]; cdsp = &CDSp->cds_table[nDrive];
@ -413,7 +419,7 @@ struct f_node FAR *
if (cdsp->cdsFlags & CDSNETWDRV) { if (cdsp->cdsFlags & CDSNETWDRV) {
printf("split path called for redirected file: `%s.%s'\n", printf("split path called for redirected file: `%s.%s'\n",
fname, fext); fname, fext);
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
#endif #endif
@ -423,10 +429,10 @@ struct f_node FAR *
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit... */ /* requested file was not open, tell the caller and exit... */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
{ {
dir_close(fnp); dir_close(fnp);
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
/* Convert the name into an absolute name for comparison... */ /* Convert the name into an absolute name for comparison... */
@ -437,7 +443,7 @@ struct f_node FAR *
return fnp; return fnp;
} }
static BOOL find_fname(struct f_node FAR * fnp, BYTE * fname, BYTE * fext) STATIC BOOL find_fname(f_node_ptr fnp, BYTE * fname, BYTE * fext)
{ {
BOOL found = FALSE; BOOL found = FALSE;
@ -469,14 +475,14 @@ static BOOL find_fname(struct f_node FAR * fnp, BYTE * fname, BYTE * fext)
reasons, since DOS without SHARE does not share changes reasons, since DOS without SHARE does not share changes
between two or more open instances of the same file between two or more open instances of the same file
unless these instances were generated by dup() or dup2(). */ unless these instances were generated by dup() or dup2(). */
static void merge_file_changes(struct f_node FAR *fnp, int collect) { STATIC void merge_file_changes(f_node_ptr fnp, int collect) {
struct f_node FAR *fnp2; f_node_ptr fnp2;
int i; int i;
if (!IsShareInstalled()) return; if (!IsShareInstalled()) return;
for (i = 0; i < f_nodes_cnt; i++) { for (i = 0; i < f_nodes_cnt; i++) {
fnp2 = &f_nodes[i]; fnp2 = (f_node_ptr)&f_nodes[i];
if ( (fnp != (struct f_node FAR *)0) if ( (fnp != (f_node_ptr)0)
&& (fnp != fnp2) && (fnp != fnp2)
&& (fnp->f_count > 0) && (fnp->f_count > 0)
&& (is_same_file(fnp, fnp2)) ) { && (is_same_file(fnp, fnp2)) ) {
@ -501,7 +507,7 @@ static void merge_file_changes(struct f_node FAR *fnp, int collect) {
} }
/* /// Added - Ron Cemer */ /* /// Added - Ron Cemer */
static int is_same_file(struct f_node FAR *fnp1, struct f_node FAR *fnp2) { STATIC int is_same_file(f_node_ptr fnp1, f_node_ptr fnp2) {
return return
(fnp1->f_dpb->dpb_unit == fnp2->f_dpb->dpb_unit) (fnp1->f_dpb->dpb_unit == fnp2->f_dpb->dpb_unit)
&& (fnp1->f_dpb->dpb_subunit == fnp2->f_dpb->dpb_subunit) && (fnp1->f_dpb->dpb_subunit == fnp2->f_dpb->dpb_subunit)
@ -520,7 +526,7 @@ static int is_same_file(struct f_node FAR *fnp1, struct f_node FAR *fnp2) {
} }
/* /// Added - Ron Cemer */ /* /// Added - Ron Cemer */
static void copy_file_changes(struct f_node FAR *src, struct f_node FAR *dst) { STATIC void copy_file_changes(f_node_ptr src, f_node_ptr dst) {
dst->f_highwater = src->f_highwater; dst->f_highwater = src->f_highwater;
dst->f_dir.dir_start = src->f_dir.dir_start; dst->f_dir.dir_start = src->f_dir.dir_start;
dst->f_dir.dir_size = src->f_dir.dir_size; dst->f_dir.dir_size = src->f_dir.dir_size;
@ -530,7 +536,7 @@ static void copy_file_changes(struct f_node FAR *src, struct f_node FAR *dst) {
COUNT dos_creat(BYTE FAR * path, COUNT attrib) COUNT dos_creat(BYTE FAR * path, COUNT attrib)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
/* NEVER EVER allow directories to be created */ /* NEVER EVER allow directories to be created */
if (attrib & ~(D_RDONLY|D_HIDDEN|D_SYSTEM|D_ARCHIVE)) if (attrib & ~(D_RDONLY|D_HIDDEN|D_SYSTEM|D_ARCHIVE))
@ -638,7 +644,7 @@ COUNT dos_creat(BYTE FAR * path, COUNT attrib)
COUNT dos_delete(BYTE FAR * path) COUNT dos_delete(BYTE FAR * path)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
/* first split the passed dir into components (i.e. - */ /* first split the passed dir into components (i.e. - */
/* path to new directory and name of new directory */ /* path to new directory and name of new directory */
@ -687,8 +693,8 @@ COUNT dos_delete(BYTE FAR * path)
COUNT dos_rmdir(BYTE FAR * path) COUNT dos_rmdir(BYTE FAR * path)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
REG struct f_node FAR *fnp1; REG f_node_ptr fnp1;
BOOL found; BOOL found;
/* first split the passed dir into comopnents (i.e. - */ /* first split the passed dir into comopnents (i.e. - */
@ -713,7 +719,13 @@ COUNT dos_rmdir(BYTE FAR * path)
/* The only permissable attribute is directory, */ /* The only permissable attribute is directory, */
/* check for any other bit set. If it is, give */ /* check for any other bit set. If it is, give */
/* an access error. */ /* an access error. */
if (fnp->f_dir.dir_attrib & ~D_DIR) /* if (fnp->f_dir.dir_attrib & ~D_DIR) */
/* directories may have attributes, too. at least my WinNT disk
has many 'archive' directories
we still don't allow SYSTEM or RDONLY directories to be deleted TE*/
if (fnp->f_dir.dir_attrib & ~(D_DIR |D_HIDDEN|D_ARCHIVE))
{ {
dir_close(fnp); dir_close(fnp);
return DE_ACCESS; return DE_ACCESS;
@ -787,8 +799,8 @@ COUNT dos_rmdir(BYTE FAR * path)
COUNT dos_rename(BYTE FAR * path1, BYTE FAR * path2) COUNT dos_rename(BYTE FAR * path1, BYTE FAR * path2)
{ {
REG struct f_node FAR *fnp1; REG f_node_ptr fnp1;
REG struct f_node FAR *fnp2; REG f_node_ptr fnp2;
BOOL is_free; BOOL is_free;
/* first split the passed target into compnents (i.e. - path to */ /* first split the passed target into compnents (i.e. - path to */
@ -886,7 +898,7 @@ COUNT dos_rename(BYTE FAR * path1, BYTE FAR * path2)
/* */ /* */
/* wipe out all FAT entries for create, delete, etc. */ /* wipe out all FAT entries for create, delete, etc. */
/* */ /* */
static VOID wipe_out(struct f_node FAR * fnp) STATIC VOID wipe_out(f_node_ptr fnp)
{ {
REG UWORD st, REG UWORD st,
next; next;
@ -926,7 +938,7 @@ static VOID wipe_out(struct f_node FAR * fnp)
} }
} }
static BOOL find_free(struct f_node FAR * fnp) STATIC BOOL find_free(f_node_ptr fnp)
{ {
while (dir_read(fnp) == DIRENT_SIZE) while (dir_read(fnp) == DIRENT_SIZE)
{ {
@ -995,7 +1007,7 @@ time dos_gettime()
/* */ /* */
COUNT dos_getftime(COUNT fd, date FAR * dp, time FAR * tp) COUNT dos_getftime(COUNT fd, date FAR * dp, time FAR * tp)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
/* operations are achieved through fnodes. */ /* operations are achieved through fnodes. */
@ -1004,7 +1016,7 @@ COUNT dos_getftime(COUNT fd, date FAR * dp, time FAR * tp)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return DE_INVLDHNDL; return DE_INVLDHNDL;
/* Get the date and time from the fnode and return */ /* Get the date and time from the fnode and return */
@ -1019,7 +1031,7 @@ COUNT dos_getftime(COUNT fd, date FAR * dp, time FAR * tp)
/* */ /* */
COUNT dos_setftime(COUNT fd, date FAR * dp, time FAR * tp) COUNT dos_setftime(COUNT fd, date FAR * dp, time FAR * tp)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
/* operations are achieved through fnodes. */ /* operations are achieved through fnodes. */
@ -1028,7 +1040,7 @@ COUNT dos_setftime(COUNT fd, date FAR * dp, time FAR * tp)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return DE_INVLDHNDL; return DE_INVLDHNDL;
/* Set the date and time from the fnode and return */ /* Set the date and time from the fnode and return */
@ -1043,7 +1055,7 @@ COUNT dos_setftime(COUNT fd, date FAR * dp, time FAR * tp)
/* */ /* */
LONG dos_getcufsize(COUNT fd) LONG dos_getcufsize(COUNT fd)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
/* operations are achieved through fnodes. */ /* operations are achieved through fnodes. */
@ -1052,7 +1064,7 @@ LONG dos_getcufsize(COUNT fd)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return -1l; return -1l;
/* Return the file size */ /* Return the file size */
@ -1064,7 +1076,7 @@ LONG dos_getcufsize(COUNT fd)
/* */ /* */
LONG dos_getfsize(COUNT fd) LONG dos_getfsize(COUNT fd)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
/* operations are achieved through fnodes. */ /* operations are achieved through fnodes. */
@ -1073,7 +1085,7 @@ LONG dos_getfsize(COUNT fd)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return -1l; return -1l;
/* Return the file size */ /* Return the file size */
@ -1085,7 +1097,7 @@ LONG dos_getfsize(COUNT fd)
/* */ /* */
BOOL dos_setfsize(COUNT fd, LONG size) BOOL dos_setfsize(COUNT fd, LONG size)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
/* operations are achieved through fnodes. */ /* operations are achieved through fnodes. */
@ -1094,7 +1106,7 @@ BOOL dos_setfsize(COUNT fd, LONG size)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return FALSE; return FALSE;
/* Change the file size */ /* Change the file size */
@ -1109,7 +1121,7 @@ BOOL dos_setfsize(COUNT fd, LONG size)
/* */ /* */
/* Find free cluster in disk FAT table */ /* Find free cluster in disk FAT table */
/* */ /* */
static UWORD find_fat_free(struct f_node FAR * fnp) STATIC UWORD find_fat_free(f_node_ptr fnp)
{ {
REG UWORD idx; REG UWORD idx;
@ -1144,15 +1156,14 @@ static UWORD find_fat_free(struct f_node FAR * fnp)
} }
/* */ /* */
/* crate a directory - returns success or a negative error */ /* create a directory - returns success or a negative error */
/* number */ /* number */
/* */ /* */
COUNT dos_mkdir(BYTE FAR * dir) COUNT dos_mkdir(BYTE FAR * dir)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
REG COUNT idx; REG COUNT idx;
struct buffer FAR *bp; struct buffer FAR *bp;
BYTE FAR *p;
UWORD free_fat; UWORD free_fat;
UWORD parent; UWORD parent;
@ -1164,6 +1175,28 @@ COUNT dos_mkdir(BYTE FAR * dir)
return DE_PATHNOTFND; return DE_PATHNOTFND;
} }
/* check that the resulting combined path does not exceed
the 64 PARSE_MAX limit. this leeds to problems:
A) you can't CD to this directory later
B) you can't create files in this subdirectory
C) the created dir will not be found later, so you
can create an unlimited amount of same dirs. this space
is lost forever
*/
if (2 /* "C" */
+ strlen(szDirName)
+ 1 /* "\\" */
+ FileName83Length(szFileName) /* the SZ is not SZ, of course */
> PARSE_MAX+2)
{
dir_close(fnp);
return DE_PATHNOTFND;
}
/* Check that we don't have a duplicate name, so if we */ /* Check that we don't have a duplicate name, so if we */
/* find one, it's an error. */ /* find one, it's an error. */
if (find_fname(fnp, szFileName, szFileExt)) if (find_fname(fnp, szFileName, szFileExt))
@ -1244,7 +1277,8 @@ COUNT dos_mkdir(BYTE FAR * dir)
/* Craft the new directory. Note that if we're in a new */ /* Craft the new directory. Note that if we're in a new */
/* directory just under the root, ".." pointer is 0. */ /* directory just under the root, ".." pointer is 0. */
bp = getblock((ULONG) clus2phys(free_fat, /* as we are overwriting it completely, don't read first */
bp = getblockOver((ULONG) clus2phys(free_fat,
(fnp->f_dpb->dpb_clsmask + 1), (fnp->f_dpb->dpb_clsmask + 1),
fnp->f_dpb->dpb_data), fnp->f_dpb->dpb_data),
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
@ -1277,19 +1311,17 @@ COUNT dos_mkdir(BYTE FAR * dir)
putdirent((struct dirent FAR *)&DirEntBuffer, (BYTE FAR *) & bp->b_buffer[DIRENT_SIZE]); putdirent((struct dirent FAR *)&DirEntBuffer, (BYTE FAR *) & bp->b_buffer[DIRENT_SIZE]);
/* fill the rest of the block with zeros */ /* fill the rest of the block with zeros */
for (p = (BYTE FAR *) & bp->b_buffer[2 * DIRENT_SIZE]; fmemset( & bp->b_buffer[2 * DIRENT_SIZE],0, BUFFERSIZE - 2 * DIRENT_SIZE);
p < &bp->b_buffer[BUFFERSIZE];)
*p++ = NULL;
/* Mark the block to be written out */ /* Mark the block to be written out */
bp->b_flag |= BFR_DIRTY; bp->b_flag |= BFR_DIRTY | BFR_VALID;
/* clear out the rest of the blocks in the cluster */ /* clear out the rest of the blocks in the cluster */
for (idx = 1; idx < (fnp->f_dpb->dpb_clsmask + 1); idx++) for (idx = 1; idx < (fnp->f_dpb->dpb_clsmask + 1); idx++)
{ {
REG COUNT i;
bp = getblock((ULONG) clus2phys(fnp->f_dir.dir_start, /* as we are overwriting it completely, don't read first */
bp = getblockOver((ULONG) clus2phys(fnp->f_dir.dir_start,
(fnp->f_dpb->dpb_clsmask + 1), (fnp->f_dpb->dpb_clsmask + 1),
fnp->f_dpb->dpb_data) + idx, fnp->f_dpb->dpb_data) + idx,
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
@ -1301,9 +1333,9 @@ COUNT dos_mkdir(BYTE FAR * dir)
dir_close(fnp); dir_close(fnp);
return DE_BLKINVLD; return DE_BLKINVLD;
} }
for (i = 0, p = (BYTE FAR *) bp->b_buffer; i < BUFFERSIZE; i++) fmemset(bp->b_buffer, 0, BUFFERSIZE);
*p++ = NULL; bp->b_flag |= BFR_DIRTY | BFR_VALID;
bp->b_flag |= BFR_DIRTY; bp->b_flag |= BFR_UNCACHE; /* need not be cached */
} }
/* flush the drive buffers so that all info is written */ /* flush the drive buffers so that all info is written */
@ -1316,12 +1348,12 @@ COUNT dos_mkdir(BYTE FAR * dir)
return SUCCESS; return SUCCESS;
} }
BOOL last_link(struct f_node FAR * fnp) BOOL last_link(f_node_ptr fnp)
{ {
return (((UWORD) fnp->f_cluster == (UWORD) LONG_LAST_CLUSTER)); return (((UWORD) fnp->f_cluster == (UWORD) LONG_LAST_CLUSTER));
} }
static BOOL extend(struct f_node FAR * fnp) STATIC BOOL extend(f_node_ptr fnp)
{ {
UWORD free_fat; UWORD free_fat;
@ -1347,7 +1379,7 @@ static BOOL extend(struct f_node FAR * fnp)
return TRUE; return TRUE;
} }
static COUNT extend_dir(struct f_node FAR * fnp) STATIC COUNT extend_dir(f_node_ptr fnp)
{ {
REG COUNT idx; REG COUNT idx;
@ -1360,11 +1392,9 @@ static COUNT extend_dir(struct f_node FAR * fnp)
/* clear out the rest of the blocks in the cluster */ /* clear out the rest of the blocks in the cluster */
for (idx = 0; idx < (fnp->f_dpb->dpb_clsmask + 1); idx++) for (idx = 0; idx < (fnp->f_dpb->dpb_clsmask + 1); idx++)
{ {
REG COUNT i;
REG BYTE FAR *p;
REG struct buffer FAR *bp; REG struct buffer FAR *bp;
bp = getblock((ULONG) clus2phys(fnp->f_cluster, bp = getblockOver((ULONG) clus2phys(fnp->f_cluster,
(fnp->f_dpb->dpb_clsmask + 1), (fnp->f_dpb->dpb_clsmask + 1),
fnp->f_dpb->dpb_data) + idx, fnp->f_dpb->dpb_data) + idx,
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
@ -1376,9 +1406,11 @@ static COUNT extend_dir(struct f_node FAR * fnp)
dir_close(fnp); dir_close(fnp);
return DE_BLKINVLD; return DE_BLKINVLD;
} }
for (i = 0, p = (BYTE FAR *) bp->b_buffer; i < BUFFERSIZE; i++) fmemset(bp->b_buffer,0, BUFFERSIZE);
*p++ = NULL; bp->b_flag |= BFR_DIRTY | BFR_VALID;
bp->b_flag |= BFR_DIRTY;
if (idx != 0)
bp->b_flag |= BFR_UNCACHE; /* needs not be cached */
} }
if (!find_free(fnp)) if (!find_free(fnp))
@ -1395,7 +1427,7 @@ static COUNT extend_dir(struct f_node FAR * fnp)
} }
/* JPP: finds the next free cluster in the FAT */ /* JPP: finds the next free cluster in the FAT */
static BOOL first_fat(struct f_node FAR * fnp) STATIC BOOL first_fat(f_node_ptr fnp)
{ {
UWORD free_fat; UWORD free_fat;
@ -1424,10 +1456,10 @@ static BOOL first_fat(struct f_node FAR * fnp)
/* JPP: new map_cluster. If we are moving forward, then use the offset /* JPP: new map_cluster. If we are moving forward, then use the offset
that we are at now (f_cluster_offset) to start, instead of starting that we are at now (f_cluster_offset) to start, instead of starting
at the beginning. */ at the beginning. */
COUNT map_cluster(REG struct f_node FAR * fnp, COUNT mode) COUNT map_cluster(REG f_node_ptr fnp, COUNT mode)
{ {
ULONG idx; ULONG idx;
UWORD clssize; ULONG clssize; /* might be 64K (by WinNT) TE */
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("map_cluster: current %lu, offset %lu, diff=%lu ", printf("map_cluster: current %lu, offset %lu, diff=%lu ",
@ -1435,7 +1467,7 @@ COUNT map_cluster(REG struct f_node FAR * fnp, COUNT mode)
fnp->f_offset - fnp->f_cluster_offset); fnp->f_offset - fnp->f_cluster_offset);
#endif #endif
/* The variable clssize will be used later. */ /* The variable clssize will be used later. */
clssize = fnp->f_dpb->dpb_secsize * (fnp->f_dpb->dpb_clsmask + 1); clssize = (ULONG)fnp->f_dpb->dpb_secsize * (fnp->f_dpb->dpb_clsmask + 1);
/* If someone did a seek, but no writes have occured, we will */ /* If someone did a seek, but no writes have occured, we will */
/* need to initialize the fnode. */ /* need to initialize the fnode. */
@ -1504,7 +1536,7 @@ COUNT map_cluster(REG struct f_node FAR * fnp, COUNT mode)
/* Read block from disk */ /* Read block from disk */
UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err) UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
REG struct buffer FAR *bp; REG struct buffer FAR *bp;
UCOUNT xfr_cnt = 0; UCOUNT xfr_cnt = 0;
UCOUNT ret_cnt = 0; UCOUNT ret_cnt = 0;
@ -1525,7 +1557,7 @@ UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
{ {
*err = DE_INVLDHNDL; *err = DE_INVLDHNDL;
return 0; return 0;
@ -1650,7 +1682,7 @@ UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
#ifdef DISPLAY_GETBLOCK #ifdef DISPLAY_GETBLOCK
printf("DATA (readblock)\n"); printf("DATA (readblock)\n");
#endif #endif
if (bp == (struct buffer *)0) if (bp == NULL) /* (struct buffer *)0 --> DS:0 !! */
{ {
*err = DE_BLKINVLD; *err = DE_BLKINVLD;
return ret_cnt; return ret_cnt;
@ -1669,6 +1701,15 @@ UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
fbcopy((BYTE FAR *) & bp->b_buffer[fnp->f_boff], buffer, xfr_cnt); fbcopy((BYTE FAR *) & bp->b_buffer[fnp->f_boff], buffer, xfr_cnt);
/* complete buffer read ?
probably not reused later
*/
if (xfr_cnt == sizeof(bp->b_buffer) ||
fnp->f_offset + xfr_cnt == fnp->f_dir.dir_size )
{
bp->b_flag |= BFR_UNCACHE;
}
/* update pointers and counters */ /* update pointers and counters */
ret_cnt += xfr_cnt; ret_cnt += xfr_cnt;
to_xfer -= xfr_cnt; to_xfer -= xfr_cnt;
@ -1682,7 +1723,7 @@ UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
/* Write block to disk */ /* Write block to disk */
UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err) UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
struct buffer FAR *bp; struct buffer FAR *bp;
UCOUNT xfr_cnt = 0; UCOUNT xfr_cnt = 0;
UCOUNT ret_cnt = 0; UCOUNT ret_cnt = 0;
@ -1703,7 +1744,7 @@ UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
{ {
*err = DE_INVLDHNDL; *err = DE_INVLDHNDL;
return 0; return 0;
@ -1872,19 +1913,22 @@ UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
potential problems. potential problems.
- Ron Cemer */ - Ron Cemer */
if ( (fnp->f_boff == 0) && (xfr_cnt == secsize) ) { if ( (fnp->f_boff == 0) && (xfr_cnt == secsize) ) {
if (!getbuf(&bp, (ULONG) clus2phys(fnp->f_cluster, bp = getblockOver((ULONG) clus2phys(fnp->f_cluster,
(fnp->f_dpb->dpb_clsmask + 1), (fnp->f_dpb->dpb_clsmask + 1),
fnp->f_dpb->dpb_data) + fnp->f_sector, fnp->f_dpb->dpb_data) + fnp->f_sector,
fnp->f_dpb->dpb_unit)) { fnp->f_dpb->dpb_unit);
*err = DE_BLKINVLD;
return ret_cnt;
}
} else { } else {
bp = getblock((ULONG) clus2phys(fnp->f_cluster, bp = getblock((ULONG) clus2phys(fnp->f_cluster,
(fnp->f_dpb->dpb_clsmask + 1), (fnp->f_dpb->dpb_clsmask + 1),
fnp->f_dpb->dpb_data) + fnp->f_sector, fnp->f_dpb->dpb_data) + fnp->f_sector,
fnp->f_dpb->dpb_unit); fnp->f_dpb->dpb_unit);
} }
if (bp == NULL) {
*err = DE_BLKINVLD;
return ret_cnt;
}
/* transfer a block */ /* transfer a block */
/* Transfer size as either a full block size, or the */ /* Transfer size as either a full block size, or the */
@ -1899,6 +1943,12 @@ UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err)
fbcopy(buffer, (BYTE FAR *) & bp->b_buffer[fnp->f_boff], xfr_cnt); fbcopy(buffer, (BYTE FAR *) & bp->b_buffer[fnp->f_boff], xfr_cnt);
bp->b_flag |= BFR_DIRTY | BFR_VALID; bp->b_flag |= BFR_DIRTY | BFR_VALID;
if (xfr_cnt == sizeof(bp->b_buffer)) /* probably not used later */
{
bp->b_flag |= BFR_UNCACHE;
}
fnp->f_flags.f_dmod = TRUE; /* mark file as modified */ fnp->f_flags.f_dmod = TRUE; /* mark file as modified */
@ -1930,7 +1980,7 @@ COUNT dos_read(COUNT fd, VOID FAR * buffer, UCOUNT count)
#ifndef IPL #ifndef IPL
COUNT dos_write(COUNT fd, VOID FAR * buffer, UCOUNT count) COUNT dos_write(COUNT fd, VOID FAR * buffer, UCOUNT count)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
COUNT err, COUNT err,
xfr; xfr;
@ -1943,7 +1993,7 @@ COUNT dos_write(COUNT fd, VOID FAR * buffer, UCOUNT count)
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
{ {
return DE_INVLDHNDL; return DE_INVLDHNDL;
} }
@ -1975,7 +2025,7 @@ COUNT dos_write(COUNT fd, VOID FAR * buffer, UCOUNT count)
/* Returns a long current offset or a negative error code */ /* Returns a long current offset or a negative error code */
LONG dos_lseek(COUNT fd, LONG foffset, COUNT origin) LONG dos_lseek(COUNT fd, LONG foffset, COUNT origin)
{ {
REG struct f_node FAR *fnp; REG f_node_ptr fnp;
/* Translate the fd into a useful pointer */ /* Translate the fd into a useful pointer */
@ -1985,7 +2035,7 @@ LONG dos_lseek(COUNT fd, LONG foffset, COUNT origin)
/* requested file was not open, tell the caller and exit */ /* requested file was not open, tell the caller and exit */
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if (fnp == (struct f_node FAR *)0 || fnp->f_count <= 0) if (fnp == (f_node_ptr)0 || fnp->f_count <= 0)
return (LONG) DE_INVLDHNDL; return (LONG) DE_INVLDHNDL;
/* now do the actual lseek adjustment to the file poitner */ /* now do the actual lseek adjustment to the file poitner */
@ -2043,7 +2093,7 @@ UWORD dos_free(struct dpb FAR *dpbp)
#ifndef IPL #ifndef IPL
COUNT dos_cd(struct cds FAR * cdsp, BYTE FAR *PathName) COUNT dos_cd(struct cds FAR * cdsp, BYTE FAR *PathName)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
/* first check for valid drive */ /* first check for valid drive */
if (cdsp->cdsDpb == 0) if (cdsp->cdsDpb == 0)
@ -2060,14 +2110,14 @@ COUNT dos_cd(struct cds FAR * cdsp, BYTE FAR *PathName)
cdsp->cdsStrtClst = fnp->f_dirstart; cdsp->cdsStrtClst = fnp->f_dirstart;
dir_close(fnp); dir_close(fnp);
fscopy(&PathName[0], cdsp->cdsCurrentPath); fstrncpy(cdsp->cdsCurrentPath,&PathName[0],sizeof(cdsp->cdsCurrentPath)-1);
return SUCCESS; return SUCCESS;
} }
#endif #endif
/* Try to allocate an f_node from the available files array */ /* Try to allocate an f_node from the available files array */
struct f_node FAR *get_f_node(void) f_node_ptr get_f_node(void)
{ {
REG i; REG i;
@ -2079,10 +2129,10 @@ struct f_node FAR *get_f_node(void)
return &f_nodes[i]; return &f_nodes[i];
} }
} }
return (struct f_node FAR *)0; return (f_node_ptr)0;
} }
VOID release_f_node(struct f_node FAR * fnp) VOID release_f_node(f_node_ptr fnp)
{ {
if (fnp->f_count > 0) if (fnp->f_count > 0)
--fnp->f_count; --fnp->f_count;
@ -2098,7 +2148,7 @@ VOID dos_setdta(BYTE FAR * newdta)
COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp) COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
COUNT fd; COUNT fd;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
@ -2107,7 +2157,7 @@ COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp)
return DE_FILENOTFND; return DE_FILENOTFND;
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if ((fnp = xlt_fd(fd)) == (struct f_node FAR *)0) if ((fnp = xlt_fd(fd)) == (f_node_ptr)0)
return DE_TOOMANY; return DE_TOOMANY;
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
@ -2126,7 +2176,7 @@ COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp)
COUNT dos_setfattr(BYTE FAR * name, UWORD FAR * attrp) COUNT dos_setfattr(BYTE FAR * name, UWORD FAR * attrp)
{ {
struct f_node FAR *fnp; f_node_ptr fnp;
COUNT fd; COUNT fd;
/* Translate the fd into an fnode pointer, since all internal */ /* Translate the fd into an fnode pointer, since all internal */
@ -2135,7 +2185,7 @@ COUNT dos_setfattr(BYTE FAR * name, UWORD FAR * attrp)
return DE_FILENOTFND; return DE_FILENOTFND;
/* note: an invalid fd is indicated by a 0 return */ /* note: an invalid fd is indicated by a 0 return */
if ((fnp = xlt_fd(fd)) == (struct f_node FAR *)0) if ((fnp = xlt_fd(fd)) == (f_node_ptr)0)
return DE_TOOMANY; return DE_TOOMANY;
/* If the fd was invalid because it was out of range or the */ /* If the fd was invalid because it was out of range or the */
@ -2292,13 +2342,13 @@ COUNT media_check(REG struct dpb FAR * dpbp)
} }
/* translate the fd into an f_node pointer */ /* translate the fd into an f_node pointer */
struct f_node FAR *xlt_fd(COUNT fd) f_node_ptr xlt_fd(COUNT fd)
{ {
return fd >= f_nodes_cnt ? (struct f_node FAR *)0 : &f_nodes[fd]; return fd >= f_nodes_cnt ? (f_node_ptr)0 : &f_nodes[fd];
} }
/* translate the f_node pointer into an fd */ /* translate the f_node pointer into an fd */
COUNT xlt_fnp(struct f_node FAR * fnp) COUNT xlt_fnp(f_node_ptr fnp)
{ {
return (COUNT)(fnp - f_nodes); return (COUNT)(fnp - f_nodes);
} }

125
kernel/fattab.c
View File

@ -35,6 +35,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.6 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.5 2001/04/21 22:32:53 bartoldeman * Revision 1.5 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -122,6 +125,33 @@ UWORD next_cl16();
/* */ /* */
/************************************************************************/ /************************************************************************/
struct buffer FAR *getFATblock(UWORD cluster, struct dpb FAR *dpbp)
{
ULONG sector;
struct buffer FAR *bp;
if (ISFAT12(dpbp))
{
sector = ((cluster << 1) + cluster) >> 1;
}
else /* FAT16 */
{
sector = (ULONG)cluster * SIZEOF_CLST16;
}
sector = sector / dpbp->dpb_secsize + dpbp->dpb_fatstrt;
bp = getblock(sector, dpbp->dpb_unit);
if (bp)
{
bp->b_flag &= ~(BFR_DATA | BFR_DIR);
bp->b_flag |= BFR_FAT | BFR_VALID;
bp->b_copies = dpbp->dpb_fats;
bp->b_offset_lo = dpbp->dpb_fatsize;
bp->b_offset_hi = dpbp->dpb_fatsize >> 8;
}
return bp;
}
/* */ /* */
/* The FAT file system is difficult to trace through FAT table. */ /* The FAT file system is difficult to trace through FAT table. */
/* There are two kinds of FAT's, 12 bit and 16 bit. The 16 bit */ /* There are two kinds of FAT's, 12 bit and 16 bit. The 16 bit */
@ -152,30 +182,21 @@ UCOUNT link_fat16(struct dpb FAR *dpbp, UCOUNT Cluster1, UCOUNT Cluster2)
{ {
UCOUNT idx; UCOUNT idx;
struct buffer FAR *bp; struct buffer FAR *bp;
UWORD Cl2 = Cluster2;
/* Get the block that this cluster is in */ /* Get the block that this cluster is in */
bp = getblock((ULONG) (((ULONG) Cluster1) * SIZEOF_CLST16) / dpbp->dpb_secsize + dpbp->dpb_fatstrt, bp = getFATblock( Cluster1, dpbp);
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (link_fat16)\n");
#endif
if (bp == NULL) if (bp == NULL)
return DE_BLKINVLD; return DE_BLKINVLD;
bp->b_flag &= ~(BFR_DATA | BFR_DIR);
bp->b_flag |= BFR_FAT;
bp->b_copies = dpbp->dpb_fats;
bp->b_offset_lo = dpbp->dpb_fatsize;
bp->b_offset_hi = dpbp->dpb_fatsize >> 8;
/* form an index so that we can read the block as a */ /* form an index so that we can read the block as a */
/* byte array */ /* byte array */
idx = (UWORD)((((LONG) Cluster1) * SIZEOF_CLST16) % dpbp->dpb_secsize); idx = (UWORD)(( Cluster1 * SIZEOF_CLST16) % dpbp->dpb_secsize);
/* Finally, put the word into the buffer and mark the */ /* Finally, put the word into the buffer and mark the */
/* buffer as dirty. */ /* buffer as dirty. */
fputword((WORD FAR *) & Cl2, (VOID FAR *) & (bp->b_buffer[idx])); fputword((WORD FAR *) & Cluster2, (VOID FAR *) & (bp->b_buffer[idx]));
bp->b_flag |= BFR_DIRTY; bp->b_flag |= BFR_DIRTY | BFR_VALID;
/* Return successful. */ /* Return successful. */
/* update the free space count */ /* update the free space count */
@ -206,18 +227,9 @@ UCOUNT link_fat12(struct dpb FAR *dpbp, UCOUNT Cluster1, UCOUNT Cluster2)
FAR * bp1; FAR * bp1;
/* Get the block that this cluster is in */ /* Get the block that this cluster is in */
bp = getblock((ULONG) ((((Cluster1 << 1) + Cluster1) >> 1) / dpbp->dpb_secsize + dpbp->dpb_fatstrt), bp = getFATblock(Cluster1 , dpbp);
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (link_fat12)\n");
#endif
if (bp == NULL) if (bp == NULL)
return DE_BLKINVLD; return DE_BLKINVLD;
bp->b_flag &= ~(BFR_DATA | BFR_DIR);
bp->b_flag |= BFR_FAT;
bp->b_copies = dpbp->dpb_fats;
bp->b_offset_lo = dpbp->dpb_fatsize;
bp->b_offset_hi = dpbp->dpb_fatsize >> 8;
/* form an index so that we can read the block as a */ /* form an index so that we can read the block as a */
/* byte array */ /* byte array */
@ -229,26 +241,18 @@ UCOUNT link_fat12(struct dpb FAR *dpbp, UCOUNT Cluster1, UCOUNT Cluster2)
/* block. */ /* block. */
if (idx >= dpbp->dpb_secsize - 1) if (idx >= dpbp->dpb_secsize - 1)
{ {
bp1 = getblock((ULONG) (dpbp->dpb_fatstrt + bp1 = getFATblock(Cluster1 + 1,dpbp);
((((Cluster1 << 1) + Cluster1) >> 1) / dpbp->dpb_secsize)) if (bp1 == 0)
+ 1,
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (link_fat12)\n");
#endif
if (bp1 == (struct buffer *)0)
return DE_BLKINVLD; return DE_BLKINVLD;
bp1->b_flag &= ~(BFR_DATA | BFR_DIR);
bp1->b_flag |= BFR_FAT | BFR_DIRTY; bp1->b_flag |= BFR_DIRTY | BFR_VALID;
bp1->b_copies = dpbp->dpb_fats;
bp1->b_offset_lo = dpbp->dpb_fatsize;
bp1->b_offset_hi = dpbp->dpb_fatsize >> 8;
fbp1 = (UBYTE FAR *) & (bp1->b_buffer[0]); fbp1 = (UBYTE FAR *) & (bp1->b_buffer[0]);
} }
else else
fbp1 = (UBYTE FAR *) & (bp->b_buffer[idx + 1]); fbp1 = (UBYTE FAR *) & (bp->b_buffer[idx + 1]);
fbp0 = (UBYTE FAR *) & (bp->b_buffer[idx]); fbp0 = (UBYTE FAR *) & (bp->b_buffer[idx]);
bp->b_flag |= BFR_DIRTY; bp->b_flag |= BFR_DIRTY | BFR_VALID;
/* Now pack the value in */ /* Now pack the value in */
if (Cluster1 & 0x01) if (Cluster1 & 0x01)
@ -298,20 +302,10 @@ UWORD next_cl16(struct dpb FAR *dpbp, UCOUNT ClusterNum)
struct buffer FAR *bp; struct buffer FAR *bp;
/* Get the block that this cluster is in */ /* Get the block that this cluster is in */
bp = getblock((ULONG) (((ULONG) ClusterNum) * SIZEOF_CLST16) / dpbp->dpb_secsize + dpbp->dpb_fatstrt, bp = getFATblock( ClusterNum, dpbp);
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (next_cl16)\n");
#endif
if (bp == NULL) if (bp == NULL)
return DE_BLKINVLD; return DE_BLKINVLD;
bp->b_flag &= ~(BFR_DATA | BFR_DIR);
bp->b_flag |= BFR_FAT;
bp->b_copies = dpbp->dpb_fats;
bp->b_offset_lo = dpbp->dpb_fatsize;
bp->b_offset_hi = dpbp->dpb_fatsize >> 8;
#ifndef I86 #ifndef I86
UCOUNT idx; UCOUNT idx;
@ -330,7 +324,7 @@ UWORD next_cl16(struct dpb FAR *dpbp, UCOUNT ClusterNum)
#else #else
/* this saves 2 WORDS of stack :-) */ /* this saves 2 WORDS of stack :-) */
return *(WORD FAR *)&(bp->b_buffer[(ClusterNum * SIZEOF_CLST16) % dpbp->dpb_secsize]); return *(UWORD FAR *)&(bp->b_buffer[(ClusterNum * SIZEOF_CLST16) % dpbp->dpb_secsize]);
#endif #endif
@ -345,18 +339,10 @@ UWORD next_cl12(struct dpb FAR *dpbp, REG UCOUNT ClusterNum)
FAR * bp1; FAR * bp1;
/* Get the block that this cluster is in */ /* Get the block that this cluster is in */
bp = getblock((ULONG) ((((ClusterNum << 1) + ClusterNum) >> 1) / dpbp->dpb_secsize + dpbp->dpb_fatstrt), bp = getFATblock(ClusterNum , dpbp);
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (next_cl12)\n");
#endif
if (bp == NULL) if (bp == NULL)
return LONG_BAD; return LONG_BAD;
bp->b_flag &= ~(BFR_DATA | BFR_DIR);
bp->b_flag |= BFR_FAT;
bp->b_copies = dpbp->dpb_fats;
bp->b_offset_lo = dpbp->dpb_fatsize;
bp->b_offset_hi = dpbp->dpb_fatsize >> 8;
/* form an index so that we can read the block as a */ /* form an index so that we can read the block as a */
/* byte array */ /* byte array */
@ -368,20 +354,11 @@ UWORD next_cl12(struct dpb FAR *dpbp, REG UCOUNT ClusterNum)
/* block. */ /* block. */
if (idx >= dpbp->dpb_secsize - 1) if (idx >= dpbp->dpb_secsize - 1)
{ {
bp1 = getblock((ULONG) (dpbp->dpb_fatstrt + bp1 = getFATblock(ClusterNum +1, dpbp);
((((ClusterNum << 1) + ClusterNum) >> 1) / dpbp->dpb_secsize))
+ 1, if (bp1 == 0)
dpbp->dpb_unit);
#ifdef DISPLAY_GETBLOCK
printf("FAT (next_cl12)\n");
#endif
if (bp1 == (struct buffer *)0)
return LONG_BAD; return LONG_BAD;
bp1->b_flag &= ~(BFR_DATA | BFR_DIR);
bp1->b_flag |= BFR_FAT;
bp1->b_copies = dpbp->dpb_fats;
bp1->b_offset_lo = dpbp->dpb_fatsize;
bp1->b_offset_hi = dpbp->dpb_fatsize >> 8;
fbp1 = (UBYTE FAR *) & (bp1->b_buffer[0]); fbp1 = (UBYTE FAR *) & (bp1->b_buffer[0]);
} }
else else

35
kernel/fcbfns.c
View File

@ -35,6 +35,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.11 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.10 2001/04/21 22:32:53 bartoldeman * Revision 1.10 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -157,32 +160,42 @@ VOID MoveDirInfo();
static dmatch Dmatch; static dmatch Dmatch;
VOID FatGetDrvData(COUNT drive, COUNT FAR * spc, COUNT FAR * bps, VOID FatGetDrvData(UCOUNT drive, COUNT FAR * spc, COUNT FAR * bps,
COUNT FAR * nc, BYTE FAR ** mdp) COUNT FAR * nc, BYTE FAR ** mdp)
{ {
struct dpb FAR *dpbp; struct dpb FAR *dpbp;
struct cds FAR *cdsp;
printf("FGDD\n");
/* first check for valid drive */ /* first check for valid drive */
if ((UCOUNT)drive >= lastdrive)
{
*spc = -1; *spc = -1;
drive = (drive == 0 ? default_drive : drive - 1);
if (drive >= lastdrive)
return;
cdsp = &CDSp->cds_table[drive];
if (!(cdsp->cdsFlags & CDSVALID))
return; return;
}
/* next - "log" in the drive */ /* next - "log" in the drive */
drive = (drive == 0 ? default_drive : drive - 1); if (cdsp->cdsFlags & CDSNETWDRV) {
if (CDSp->cds_table[drive].cdsFlags & CDSNETWDRV) { /* Undoc DOS says, its not supported for
printf("FatGetDrvData not yet supported over network drives\n"); network drives. so it's probably OK */
*spc = -1; /*printf("FatGetDrvData not yet supported over network drives\n");*/
return; return;
} }
dpbp = CDSp->cds_table[drive].cdsDpb; dpbp = CDSp->cds_table[drive].cdsDpb;
if (dpbp == NULL)
{
return;
}
dpbp->dpb_flags = -1; dpbp->dpb_flags = -1;
if ((media_check(dpbp) < 0)) if ((media_check(dpbp) < 0))
{ {
*spc = -1;
return; return;
} }

15
kernel/globals.h
View File

@ -36,6 +36,9 @@ static BYTE *Globals_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.13 2001/06/03 14:16:17 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.12 2001/04/21 22:32:53 bartoldeman * Revision 1.12 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -557,16 +560,20 @@ extern struct cds
GLOBAL seg GLOBAL seg
RootPsp; /* Root process -- do not abort */ RootPsp; /* Root process -- do not abort */
/* don't know what it should do, but its no longer in use TE
GLOBAL struct f_node GLOBAL struct f_node
*pDirFileNode; *pDirFileNode;
*/
#ifdef DEBUG
GLOBAL iregs error_regs; /* registers for dump */ GLOBAL iregs error_regs; /* registers for dump */
GLOBAL WORD GLOBAL WORD
dump_regs; /* dump registers of bad call */ dump_regs; /* dump registers of bad call */
GLOBAL struct f_node FAR #endif
* f_nodes; /* pointer to the array */
GLOBAL f_node_ptr f_nodes; /* pointer to the array */
GLOBAL UWORD f_nodes_cnt; /* number of allocated f_nodes */ GLOBAL UWORD f_nodes_cnt; /* number of allocated f_nodes */
@ -574,8 +581,8 @@ GLOBAL struct buffer
FAR *lastbuf; /* tail of ditto */ FAR *lastbuf; /* tail of ditto */
/* FAR * buffers; /* pointer to array of track buffers */ /* FAR * buffers; /* pointer to array of track buffers */
GLOBAL BYTE /* scratchpad used for working around */ /*GLOBAL BYTE FAR * dma_scratch;*/ /* scratchpad used for working around */
FAR * dma_scratch; /* DMA transfers during disk I/O */ /* DMA transfers during disk I/O */
GLOBAL iregs GLOBAL iregs
FAR * ustackp, /* user stack */ FAR * ustackp, /* user stack */

1
kernel/init-mod.h
View File

@ -152,6 +152,7 @@ int close(int fd);
int dup2(int oldfd, int newfd); int dup2(int oldfd, int newfd);
int allocmem(UWORD size, seg *segp); int allocmem(UWORD size, seg *segp);
INIT VOID init_PSPInit(seg psp_seg); INIT VOID init_PSPInit(seg psp_seg);
INIT VOID init_PSPSet(seg psp_seg);
INIT COUNT init_DosExec(COUNT mode, exec_blk * ep, BYTE * lp); INIT COUNT init_DosExec(COUNT mode, exec_blk * ep, BYTE * lp);
INIT VOID keycheck(VOID); INIT VOID keycheck(VOID);

5
kernel/inthndlr.c
View File

@ -37,6 +37,9 @@ BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.24 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.23 2001/04/29 17:34:40 bartoldeman * Revision 1.23 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -486,7 +489,7 @@ dispatch:
case 0x0a: case 0x0a:
((keyboard FAR *) FP_DS_DX)->kb_count = 0; ((keyboard FAR *) FP_DS_DX)->kb_count = 0;
sti((keyboard FAR *) FP_DS_DX); sti((keyboard FAR *) FP_DS_DX);
((keyboard FAR *) FP_DS_DX)->kb_count -= 2; ((keyboard FAR *) FP_DS_DX)->kb_count--;
break; break;
/* Check Stdin Status */ /* Check Stdin Status */

15
kernel/intr.asm
View File

@ -90,12 +90,6 @@ intr?1:
ret ret
global _int3
_int3:
int 3
retf
segment INIT_TEXT segment INIT_TEXT
; ;
; void init_call_intr(nr, rp) ; void init_call_intr(nr, rp)
@ -266,6 +260,15 @@ _init_PSPInit:
pop si pop si
ret ret
;; VOID init_PSPSet(seg psp_seg)
global _init_PSPSet
_init_PSPSet:
mov ah, 50h
mov bx, sp
mov bx, [bx+2]
int 21h
ret
;; COUNT init_DosExec(COUNT mode, exec_blk * ep, BYTE * lp) ;; COUNT init_DosExec(COUNT mode, exec_blk * ep, BYTE * lp)
global _init_DosExec global _init_DosExec
_init_DosExec: _init_DosExec:

1
kernel/intr.h
View File

@ -7,4 +7,3 @@ struct REGPACK {
}; };
extern void intr(int intrnr, struct REGPACK *rp); extern void intr(int intrnr, struct REGPACK *rp);
extern void FAR int3();

16
kernel/ioctl.c
View File

@ -35,6 +35,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.9 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.8 2001/04/15 03:21:50 bartoldeman * Revision 1.8 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -110,11 +113,6 @@ static BYTE *RcsId = "$Id$";
* Initial revision. * Initial revision.
*/ */
#ifdef PROTO
sft FAR *get_sft(COUNT);
#else
sft FAR *get_sft();
#endif
/* /*
* WARNING: this code is non-portable (8086 specific). * WARNING: this code is non-portable (8086 specific).
@ -243,12 +241,12 @@ COUNT DosDevIOctl(iregs FAR * r)
r->AL = CharReqHdr.r_status & S_BUSY ? 00 : 0xff; r->AL = CharReqHdr.r_status & S_BUSY ? 00 : 0xff;
} }
if (r->AL == 0x02 || r->AL == 0x03) else if (r->AL == 0x02 || r->AL == 0x03)
{ {
r->AX = CharReqHdr.r_count; r->AX = CharReqHdr.r_count;
} }
if (r->AL == 0x0c || r->AL == 0x10) else if (r->AL == 0x0c || r->AL == 0x10)
{ {
r->AX = CharReqHdr.r_status; r->AX = CharReqHdr.r_status;
} }
@ -300,12 +298,12 @@ COUNT DosDevIOctl(iregs FAR * r)
} }
if (r->AL == 0x04 || r->AL == 0x05) else if (r->AL == 0x04 || r->AL == 0x05)
{ {
r->AX = CharReqHdr.r_count; r->AX = CharReqHdr.r_count;
} }
if (r->AL == 0x0d || r->AL == 0x11) else if (r->AL == 0x0d || r->AL == 0x11)
{ {
r->AX = CharReqHdr.r_status; r->AX = CharReqHdr.r_status;
} }

7
kernel/kernel.asm
View File

@ -28,6 +28,9 @@
; $Id$ ; $Id$
; ;
; $Log$ ; $Log$
; Revision 1.13 2001/06/03 14:16:18 bartoldeman
; BUFFERS tuning and misc bug fixes/cleanups (2024c).
;
; Revision 1.12 2001/04/29 17:34:40 bartoldeman ; Revision 1.12 2001/04/29 17:34:40 bartoldeman
; A new SYS.COM/config.sys single stepping/console output/misc fixes. ; A new SYS.COM/config.sys single stepping/console output/misc fixes.
; ;
@ -625,7 +628,7 @@ __ib_end:
; kernel startup stack ; kernel startup stack
global init_tos global init_tos
resw 256 resw 384
init_tos: init_tos:
; the last paragraph of conventional memory might become an MCB ; the last paragraph of conventional memory might become an MCB
resb 16 resb 16
@ -916,7 +919,9 @@ __EnableA20:
enableUsingXMSdriver: enableUsingXMSdriver:
mov ah,3 mov ah,3
UsingXMSdriver: UsingXMSdriver:
push bx
call far [cs:_XMSDriverAddress] call far [cs:_XMSDriverAddress]
pop bx
retf retf
global __DisableA20 global __DisableA20

4
kernel/main.c
View File

@ -71,6 +71,9 @@ static BYTE *mainRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.17 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.16 2001/04/29 17:34:40 bartoldeman * Revision 1.16 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -300,6 +303,7 @@ INIT void init_kernel(void)
setvec(0x2f, int2f_handler); setvec(0x2f, int2f_handler);
#endif #endif
init_PSPSet(DOS_PSP);
init_PSPInit(DOS_PSP); init_PSPInit(DOS_PSP);
/* Do first initialization of system variable buffers so that */ /* Do first initialization of system variable buffers so that */

20
kernel/nls.c
View File

@ -44,6 +44,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.7 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.6 2001/04/15 03:21:50 bartoldeman * Revision 1.6 2001/04/15 03:21:50 bartoldeman
* See history.txt for the list of fixes. * See history.txt for the list of fixes.
* *
@ -337,7 +340,9 @@ log( ("NLS: nlsGetData(): subfunction found\n") );
case NLS_DOS_38: /* Normal Country Information */ case NLS_DOS_38: /* Normal Country Information */
return cpyBuf(buf, bufsize return cpyBuf(buf, bufsize
, &(((struct nlsExtCntryInfo FAR*)poi)->dateFmt) , &(((struct nlsExtCntryInfo FAR*)poi)->dateFmt)
, 34); /* standard cinfo has no more 34 _used_ bytes */ , 24); /* standard cinfo has no more 34 _used_ bytes */
/* don't copy 34, copy only 0x18 instead,
see comment at DosGetCountryInformation TE */
default: default:
/* All other subfunctions just return the found nlsPoinerInf /* All other subfunctions just return the found nlsPoinerInf
structure */ structure */
@ -356,8 +361,7 @@ log( ("NLS: nlsGetData(): Subfunction not found\n") );
VOID nlsCPchange(UWORD cp) VOID nlsCPchange(UWORD cp)
{ {
UNREFERENCED_PARAMETER(cp); UNREFERENCED_PARAMETER(cp);
printf("\7\nSorry, to change the codepage is not implemented, yet.\n\ printf("\7\nchange codepage not yet done ska\n");
Hope it's OK to proceed ignoring this call.\n-- 2000/02/26 ska\n");
} }
/* /*
@ -564,9 +568,17 @@ log( ("NLS: GetData(): subfct=%x, cp=%u, cntry=%u, bufsize=%u\n",
* it is assumed the buffer is large enough as described in RBIL, * it is assumed the buffer is large enough as described in RBIL,
* which is 34 bytes _hardcoded_. * which is 34 bytes _hardcoded_.
*/ */
/* TE 05/04/01
* NETX calls Int 21 AX=3800
* and gives a buffer of (at most) 0x20 bytes
* MSDOS 6.2 copies only 0x18 bytes
* RBIL documents 0x18 bytes and calls 10 bytes 'reserved'
* so we change the amount of copied bytes to 0x18
*/
#ifndef DosGetCountryInformation #ifndef DosGetCountryInformation
COUNT DosGetCountryInformation(UWORD cntry, VOID FAR *buf) COUNT DosGetCountryInformation(UWORD cntry, VOID FAR *buf)
{ return DosGetData(NLS_DOS_38, NLS_DEFAULT, cntry, 34, buf); { return DosGetData(NLS_DOS_38, NLS_DEFAULT, cntry, 0x18, buf);
} }
#endif #endif

34
kernel/proto.h
View File

@ -34,6 +34,9 @@ static BYTE *Proto_hRcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.17 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.16 2001/04/29 17:34:40 bartoldeman * Revision 1.16 2001/04/29 17:34:40 bartoldeman
* A new SYS.COM/config.sys single stepping/console output/misc fixes. * A new SYS.COM/config.sys single stepping/console output/misc fixes.
* *
@ -175,8 +178,8 @@ static BYTE *Proto_hRcsId = "$Id$";
/* blockio.c */ /* blockio.c */
ULONG getblkno(struct buffer FAR *); ULONG getblkno(struct buffer FAR *);
VOID setblkno(struct buffer FAR *, ULONG); VOID setblkno(struct buffer FAR *, ULONG);
struct buffer FAR *getblock(ULONG blkno, COUNT dsk); struct buffer FAR *getblock (ULONG blkno, COUNT dsk);
BOOL getbuf(struct buffer FAR ** pbp, ULONG blkno, COUNT dsk); struct buffer FAR *getblockOver(ULONG blkno, COUNT dsk);
VOID setinvld(REG COUNT dsk); VOID setinvld(REG COUNT dsk);
BOOL flush_buffers(REG COUNT dsk); BOOL flush_buffers(REG COUNT dsk);
BOOL flush1(struct buffer FAR * bp); BOOL flush1(struct buffer FAR * bp);
@ -199,7 +202,7 @@ VOID KbdFlush(void);
VOID Do_DosIdle_loop(void); VOID Do_DosIdle_loop(void);
UCOUNT sti(keyboard FAR * kp); UCOUNT sti(keyboard FAR * kp);
sft FAR *get_sft(COUNT); sft FAR *get_sft(UCOUNT);
/* dosfns.c */ /* dosfns.c */
BYTE FAR *get_root(BYTE FAR *); BYTE FAR *get_root(BYTE FAR *);
@ -256,13 +259,14 @@ COUNT char_error(request * rq, struct dhdr FAR * lpDevice);
COUNT block_error(request * rq, COUNT nDrive, struct dhdr FAR * lpDevice); COUNT block_error(request * rq, COUNT nDrive, struct dhdr FAR * lpDevice);
/* fatdir.c */ /* fatdir.c */
struct f_node FAR *dir_open(BYTE FAR * dirname); f_node_ptr dir_open(BYTE FAR * dirname);
COUNT dir_read(REG struct f_node FAR * fnp); COUNT dir_read(REG f_node_ptr fnp);
COUNT dir_write(REG struct f_node FAR * fnp); COUNT dir_write(REG f_node_ptr fnp);
VOID dir_close(REG struct f_node FAR * fnp); VOID dir_close(REG f_node_ptr fnp);
COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name); COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name);
COUNT dos_findnext(void); COUNT dos_findnext(void);
void ConvertName83ToNameSZ(BYTE FAR *destSZ, BYTE FAR *srcFCBName); void ConvertName83ToNameSZ(BYTE FAR *destSZ, BYTE FAR *srcFCBName);
int FileName83Length(BYTE *filename83);
/* fatfs.c */ /* fatfs.c */
COUNT dos_open(BYTE FAR * path, COUNT flag); COUNT dos_open(BYTE FAR * path, COUNT flag);
@ -282,8 +286,8 @@ LONG dos_getcufsize(COUNT fd);
LONG dos_getfsize(COUNT fd); LONG dos_getfsize(COUNT fd);
BOOL dos_setfsize(COUNT fd, LONG size); BOOL dos_setfsize(COUNT fd, LONG size);
COUNT dos_mkdir(BYTE FAR * dir); COUNT dos_mkdir(BYTE FAR * dir);
BOOL last_link(struct f_node FAR * fnp); BOOL last_link(f_node_ptr fnp);
COUNT map_cluster(REG struct f_node FAR * fnp, COUNT mode); COUNT map_cluster(REG f_node_ptr fnp, COUNT mode);
UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err); UCOUNT readblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err);
UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err); UCOUNT writeblock(COUNT fd, VOID FAR * buffer, UCOUNT count, COUNT * err);
COUNT dos_read(COUNT fd, VOID FAR * buffer, UCOUNT count); COUNT dos_read(COUNT fd, VOID FAR * buffer, UCOUNT count);
@ -295,14 +299,14 @@ VOID trim_path(BYTE FAR * s);
COUNT dos_cd(struct cds FAR * cdsp, BYTE FAR * PathName); COUNT dos_cd(struct cds FAR * cdsp, BYTE FAR * PathName);
struct f_node FAR *get_f_node(void); f_node_ptr get_f_node(void);
VOID release_f_node(struct f_node FAR * fnp); VOID release_f_node(f_node_ptr fnp);
VOID dos_setdta(BYTE FAR * newdta); VOID dos_setdta(BYTE FAR * newdta);
COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp); COUNT dos_getfattr(BYTE FAR * name, UWORD FAR * attrp);
COUNT dos_setfattr(BYTE FAR * name, UWORD FAR * attrp); COUNT dos_setfattr(BYTE FAR * name, UWORD FAR * attrp);
COUNT media_check(REG struct dpb FAR *dpbp); COUNT media_check(REG struct dpb FAR *dpbp);
struct f_node FAR *xlt_fd(COUNT fd); f_node_ptr xlt_fd(COUNT fd);
COUNT xlt_fnp(struct f_node FAR * fnp); COUNT xlt_fnp(f_node_ptr fnp);
struct dhdr FAR *select_unit(COUNT drive); struct dhdr FAR *select_unit(COUNT drive);
VOID bpb_to_dpb(bpb FAR *bpbp, REG struct dpb FAR * dpbp); VOID bpb_to_dpb(bpb FAR *bpbp, REG struct dpb FAR * dpbp);
@ -321,7 +325,7 @@ int DosCharInput(VOID);
VOID DosDirectConsoleIO(iregs FAR * r); VOID DosDirectConsoleIO(iregs FAR * r);
VOID DosCharOutput(COUNT c); VOID DosCharOutput(COUNT c);
VOID DosDisplayOutput(COUNT c); VOID DosDisplayOutput(COUNT c);
VOID FatGetDrvData(COUNT drive, COUNT FAR * spc, COUNT FAR * bps, COUNT FAR * nc, BYTE FAR ** mdp); VOID FatGetDrvData(UCOUNT drive, COUNT FAR * spc, COUNT FAR * bps, COUNT FAR * nc, BYTE FAR ** mdp);
WORD FcbParseFname(int wTestMode, BYTE FAR ** lpFileName, fcb FAR * lpFcb); WORD FcbParseFname(int wTestMode, BYTE FAR ** lpFileName, fcb FAR * lpFcb);
BYTE FAR *ParseSkipWh(BYTE FAR * lpFileName); BYTE FAR *ParseSkipWh(BYTE FAR * lpFileName);
BOOL TestCmnSeps(BYTE FAR * lpFileName); BOOL TestCmnSeps(BYTE FAR * lpFileName);
@ -385,7 +389,7 @@ VOID fstrcpy(REG BYTE FAR * d, REG BYTE FAR * s);
VOID fstrcpy(REG BYTE FAR * d, REG BYTE FAR * s); VOID fstrcpy(REG BYTE FAR * d, REG BYTE FAR * s);
/*VOID bcopy(REG BYTE * s, REG BYTE * d, REG COUNT n);*/ /*VOID bcopy(REG BYTE * s, REG BYTE * d, REG COUNT n);*/
void memcpy(REG BYTE * d, REG BYTE * s, REG COUNT n); void memcpy(REG void * d, REG VOID * s, REG COUNT n);
#define bcopy(s,d,n) memcpy(d,s,n) #define bcopy(s,d,n) memcpy(d,s,n)
void fmemset(REG VOID FAR * s, REG int ch, REG COUNT n); void fmemset(REG VOID FAR * s, REG int ch, REG COUNT n);

42
kernel/task.c
View File

@ -35,6 +35,9 @@ static BYTE *RcsId = "$Id$";
/* /*
* $Log$ * $Log$
* Revision 1.14 2001/06/03 14:16:18 bartoldeman
* BUFFERS tuning and misc bug fixes/cleanups (2024c).
*
* Revision 1.13 2001/04/21 22:32:53 bartoldeman * Revision 1.13 2001/04/21 22:32:53 bartoldeman
* Init DS=Init CS, fixed stack overflow problems and misc bugs. * Init DS=Init CS, fixed stack overflow problems and misc bugs.
* *
@ -234,7 +237,7 @@ COUNT ChildEnv(exec_blk FAR * exp, UWORD * pChildEnvSeg, char far * pathname)
/* create a new environment for the process */ /* create a new environment for the process */
/* copy parent's environment if exec.env_seg == 0 */ /* copy parent's environment if exec.env_seg == 0 */
pDest = pSrc = exp->exec.env_seg ? pSrc = exp->exec.env_seg ?
MK_FP(exp->exec.env_seg, 0) : MK_FP(exp->exec.env_seg, 0) :
MK_FP(ppsp->ps_environ, 0); MK_FP(ppsp->ps_environ, 0);
@ -254,24 +257,19 @@ COUNT ChildEnv(exec_blk FAR * exp, UWORD * pChildEnvSeg, char far * pathname)
-- 1999/04/21 ska */ -- 1999/04/21 ska */
if (pSrc) if (pSrc)
{ /* if no environment is available, one byte is required */ { /* if no environment is available, one byte is required */
while (*pSrc != '\0')
{
while (*pSrc != '\0' && pSrc < pDest + MAXENV - ENV_KEEPFREE)
{
++pSrc;
++nEnvSize;
}
/* account for terminating null */
++nEnvSize;
++pSrc;
}
pSrc = pDest;
}
for (nEnvSize = 0; ; nEnvSize++)
{
/* Test env size and abort if greater than max */ /* Test env size and abort if greater than max */
if (nEnvSize >= MAXENV) if (nEnvSize >= MAXENV - ENV_KEEPFREE)
return DE_INVLDENV; return DE_INVLDENV;
if (*(UWORD FAR *)(pSrc+nEnvSize) == 0)
break;
}
nEnvSize += 2; /* account for trailing \0\0 */
}
/* allocate enough space for env + path */ /* allocate enough space for env + path */
if ((RetCode = DosMemAlloc(long2para(nEnvSize + ENV_KEEPFREE), if ((RetCode = DosMemAlloc(long2para(nEnvSize + ENV_KEEPFREE),
mem_access_mode, (seg FAR *) pChildEnvSeg, mem_access_mode, (seg FAR *) pChildEnvSeg,
@ -291,20 +289,6 @@ COUNT ChildEnv(exec_blk FAR * exp, UWORD * pChildEnvSeg, char far * pathname)
else else
*pDest++ = '\0'; /* create an empty environment */ *pDest++ = '\0'; /* create an empty environment */
#if 0
/* The size is already known, use a quicker copy function
-- 1999/04/21 ska */
for (; *pSrc != '\0';)
{
while (*pSrc)
{
*pDest++ = *pSrc++;
}
pSrc++;
*pDest++ = 0;
}
*pDest++ = 0;
#endif
/* initialize 'extra strings' count */ /* initialize 'extra strings' count */
*((UWORD FAR *) pDest)++ = 1; *((UWORD FAR *) pDest)++ = 1;

5
lib/libm.mak
View File

@ -5,6 +5,9 @@
# #
# $Log$ # $Log$
# Revision 1.5 2001/06/03 14:16:18 bartoldeman
# BUFFERS tuning and misc bug fixes/cleanups (2024c).
#
# Revision 1.4 2001/03/19 04:50:56 bartoldeman # Revision 1.4 2001/03/19 04:50:56 bartoldeman
# See history.txt for overview: put kernel 2022beo1 into CVS # See history.txt for overview: put kernel 2022beo1 into CVS
# #
@ -37,7 +40,7 @@
!include "..\config.mak" !include "..\config.mak"
libm.lib: $(CLIB) libm.lib: $(CLIB) ..\config.mak
$(LIBUTIL) $(CLIB) $(MATH_EXTRACT) $(LIBUTIL) $(CLIB) $(MATH_EXTRACT)
$(LIBUTIL) libm $(MATH_INSERT) $(LIBUTIL) libm $(MATH_INSERT)
$(RM) *.OBJ $(RM) *.OBJ