Rijn/TempleOS-Rijn
1
1 Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

TempleOSCD_150216.ISO

Browse Source
This commit is contained in:
Terry A. Davis authored and minexew committed 2018-09-08 21:46:15 +02:00
1 parent 64f679eeb9
commit 401601816c
531 files changed
+23341 -22071
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Kernel/Adam1.CPP
-11
View File
@@ -1,11 +0,0 @@
//This is executed by Adam at boot.
//See $LK,"Adam1 Start-up",A="FF:::/Kernel/KEnd.CPP,Adam1:2"$
extern I8i OptEqu(I64i num,I8i val);
OptEqu(0,0); //(0,0)=EchoOff (0,1)=EchoOn
#include "/Kernel/Adam1a.HPP"
#include "/Compiler/CmpDefs.HPP"
#include "/Kernel/Adam1b.HPP"
#include "/Kernel/Adam1c.HPP"
#include "/Compiler/Cmp.HPP"
Cd("/Adam");;
#include "Adam2"
Kernel/BIOS32.CPP
+6 -11
View File
@@ -85,9 +85,9 @@ _FAR_CALL32::
PUSH U64 FS:CTask.addr[RAX]
PUSH U64 GS:CCPU.addr[RAX]
MOV U64 [C32_RSP],RSP
PUSH U32 CGDT.ds //STKSEG
PUSH U32 0x9C000 //STK
PUSH U32 0 //FLAGS--interrupts off
PUSH U32 CGDT.ds //STKSEG
PUSH U32 BOOT_RAM_LIMIT //STK
PUSH U32 0 //FLAGS--interrupts off
PUSH U32 CGDT.cs32
LEA RAX,[@@15]
PUSH RAX
@@ -132,15 +132,10 @@ C32_ADD:: DU32 0;
MOV U32 [C32_ESI],ESI
MOV U32 [C32_EDI],EDI
CALL INIT_EM64T
USE64
MOV AX,CGDT.ds
MOV DS,AX
MOV ES,AX
MOV SS,AX
MOV RSP,U64 [C32_RSP]
PUSH U32 0 //Return from next call will be 64-bit
CALL SYS_EM64T
USE64 MOV RSP,U64 [C32_RSP]
POP RAX
CALL SET_GS_BASE
POP RAX
Kernel/Compress.CPP
+39 -40
View File
@@ -1,4 +1,4 @@
//See $LK,"::/Doc/Acknowledgements.TXT"$.
//See $LK,"::/Doc/Credits.TXT"$.
//See $LK,"CArcCompress",A="MN:CArcCompress"$, $LK,"CArcEntry",A="MN:CArcEntry"$, and $LK,"CArcCtrl",A="MN:CArcCtrl"$
asm {
@@ -153,12 +153,14 @@ ac_done:
c->src_pos=src_ptr-c->src_buf;
}
U0 ArcFinishCompression(CArcCtrl *c)
Bool ArcFinishCompression(CArcCtrl *c)
{//Do closing touch on archivew ctrl struct.
if (c->dst_pos+c->cur_bits_in_use<=c->dst_size) {
BFieldOrU32(c->dst_buf,c->dst_pos,c->saved_basecode);
c->dst_pos+=c->next_bits_in_use;
}
return TRUE;
} else
return FALSE;
}
U0 ArcExpandBuf(CArcCtrl *c)
@@ -217,7 +219,7 @@ U0 ArcExpandBuf(CArcCtrl *c)
c->dst_pos=dst_ptr-c->dst_buf;
}
CArcCtrl *ArcCtrlNew(Bool expand,Bool seven_bit)
CArcCtrl *ArcCtrlNew(Bool expand,I64 compression_type=CT_8_BIT)
{//MAlloc archive ctrl struct.
CArcCtrl *c;
c=CAlloc(sizeof(CArcCtrl));
@@ -225,7 +227,7 @@ CArcCtrl *ArcCtrlNew(Bool expand,Bool seven_bit)
c->stk_base=MAlloc(ARC_MAX_ENTRY+1);
c->stk_ptr=c->stk_base;
}
if (seven_bit)
if (compression_type==CT_7_BIT)
c->min_bits=7;
else
c->min_bits=8;
@@ -246,27 +248,49 @@ U0 ArcCtrlDel(CArcCtrl *c)
Free(c);
}
CArcCompress *CompressBuf(U8 *src,I64 size,I64 flags=0,CTask *mem_task=NULL)
U8 *ExpandBuf(CArcCompress *r,CTask *mem_task=NULL)
{//See $LK,"::/Demo/Dsk/SerializeTree.CPP"$.
CArcCtrl *c;
U8 *result=MAlloc(r->expanded_size+1,mem_task);
result[r->expanded_size]=0; //terminate
switch (r->compression_type) {
case CT_NONE:
MemCpy(result,&r->body,r->expanded_size);
break;
case CT_7_BIT:
case CT_8_BIT:
c=ArcCtrlNew(TRUE,r->compression_type);
c->src_size=r->compressed_size<<3;
c->src_pos=sizeof(CArcCompress)<<3;
c->src_buf=r;
c->dst_size=r->expanded_size;
c->dst_buf=result;
c->dst_pos=0;
ArcExpandBuf(c);
ArcCtrlDel(c);
break;
default:
throw('Compress');
}
return result;
}
CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL)
{//See $LK,"::/Demo/Dsk/SerializeTree.CPP"$.
CArcCompress *result;
I64 size_out;
Bool seven_bit=ArcDetermineCompressionType(src,size)==CT_7_BIT;
CArcCtrl *c=ArcCtrlNew(FALSE,seven_bit);
I64 size_out,compression_type=ArcDetermineCompressionType(src,size);
CArcCtrl *c=ArcCtrlNew(FALSE,compression_type);
c->src_size=size;
c->src_buf=src;
c->dst_size=(size+sizeof(CArcCompress))<<3;
c->dst_buf=CAlloc(c->dst_size>>3);
c->dst_pos=sizeof(CArcCompress)<<3;
ArcCompressBuf(c);
ArcFinishCompression(c);
if (c->src_pos==c->src_size) {
if (ArcFinishCompression(c) && c->src_pos==c->src_size) {
size_out=(c->dst_pos+7)>>3;
result=MAlloc(size_out,mem_task);
MemCpy(result,c->dst_buf,size_out);
if (seven_bit)
result->compression_type=CT_7_BIT;
else
result->compression_type=CT_8_BIT;
result->compression_type=compression_type;
result->compressed_size=size_out;
} else {
result=MAlloc(size+sizeof(CArcCompress),mem_task);
@@ -275,32 +299,7 @@ CArcCompress *CompressBuf(U8 *src,I64 size,I64 flags=0,CTask *mem_task=NULL)
result->compressed_size=size+sizeof(CArcCompress);
}
result->expanded_size=size;
result->flags=flags;
Free(c->dst_buf);
ArcCtrlDel(c);
return result;
}
U8 *ExpandBuf(CArcCompress *r,CTask *mem_task=NULL)
{//See $LK,"::/Demo/Dsk/SerializeTree.CPP"$.
CArcCtrl *c;
Bool seven_bit;
U8 *result=MAlloc(r->expanded_size+1,mem_task);
result[r->expanded_size]=0; //terminate
seven_bit= r->compression_type==CT_7_BIT;
if (r->compression_type==CT_NONE)
MemCpy(result,&r->body,r->expanded_size);
else {
c=ArcCtrlNew(TRUE,seven_bit);
c->src_size=r->compressed_size<<3;
c->src_pos=sizeof(CArcCompress)<<3;
c->src_buf=r;
c->dst_size=r->expanded_size;
c->dst_buf=result;
c->dst_pos=0;
ArcExpandBuf(c);
ArcCtrlDel(c);
}
return result;
}
Kernel/Display.CPP
+9 -9
View File
@@ -47,36 +47,36 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
} else if (Bt(chars_bitmap_displayable,ch)) {
row=text.raw_col/text.cols%text.rows;
col=text.raw_col%text.cols;
if (!sys_bios_gr_mode) { //if text mode
if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode
if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
MemCpy(VGA_TEXT_MEM_BASE,VGA_TEXT_MEM_BASE+text.cols,
MemCpy(VGAM_TEXT,VGAM_TEXT+text.cols,
text.cols*(text.rows-1)*2);
MemSet(VGA_TEXT_MEM_BASE+text.cols*(text.rows-1)*2,0,text.cols*2);
MemSet(VGAM_TEXT+text.cols*(text.rows-1)*2,0,text.cols*2);
text.raw_col-=text.cols;
row=text.rows-1;
}
ptr=VGA_TEXT_MEM_BASE+(row*text.cols+col)*2;
ptr=VGAM_TEXT+(row*text.cols+col)*2;
ptr[0]=ch;
ptr[1]=BLACK<<4+WHITE;
} else {
OutU8(VGA_SC_INDEX,VGA_MAP_MASK);
OutU8(VGA_SC_DATA,0x0F); //All planes -- WHITE
OutU8(VGAP_INDEX,VGAR_MAP_MASK);
OutU8(VGAP_DATA,0x0F); //All planes -- WHITE
if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
//Scroll cached image
MemCpy(text.raw_screen_image,text.raw_screen_image+GR_WIDTH*FONT_HEIGHT>>3,
GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3);
MemSet(text.raw_screen_image+GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3,0,GR_WIDTH*FONT_HEIGHT>>3);
MemCpy(VGA_GRAPHIC_MEM_BASE,text.raw_screen_image,GR_WIDTH*GR_HEIGHT>>3);
MemCpy(VGAM_GRAPHICS,text.raw_screen_image,GR_WIDTH*GR_HEIGHT>>3);
text.raw_col-=text.cols;
row=text.rows-1;
}
PUSHFD
CLI
ptr=ptr1=col+row*GR_WIDTH*FONT_HEIGHT>>3;
ptr+=VGA_GRAPHIC_MEM_BASE;
ptr+=VGAM_GRAPHICS;
ptr1+=text.raw_screen_image; //Write to cached image as well
ptr2=&text.font[(ch&255)*FONT_HEIGHT];
ptr2=&text.font[ch&255];
for (i=0;i<FONT_HEIGHT;i++) {
*ptr=*ptr1=reverse_bits_table[*ptr2++];
ptr+=GR_WIDTH>>3;
Kernel/Dsk/Dsk1a.CPP
-721
View File
@@ -1,721 +0,0 @@
Bool BlkDevLock(CBlkDev *bdev)
{//Make this task have exclusive access to BlkDev.
BlkDevChk(bdev);
while (bdev->lock_fwding)
bdev=bdev->lock_fwding;
if (!Bt(&bdev->locked_flags,BDlf_LOCKED) || bdev->owning_task!=Fs) {
while (LBts(&bdev->locked_flags,BDlf_LOCKED))
Yield;
bdev->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool PrtLock(CPrt *p)
{//Make this task have exclusive access to Prt & BlkDev.
PrtChk(p);
BlkDevLock(p->bdev);
if (!Bt(&p->locked_flags,Plf_LOCKED) || p->owning_task!=Fs) {
while (LBts(&p->locked_flags,Plf_LOCKED))
Yield;
p->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool BlkDevUnlock(CBlkDev *bdev,Bool rst=FALSE)
{//Release exclusive lock on access to BlkDev.
BlkDevChk(bdev);
while (bdev->lock_fwding)
bdev=bdev->lock_fwding;
if (Bt(&bdev->locked_flags,BDlf_LOCKED) && bdev->owning_task==Fs) {
if (rst)
bdev->flags&=~(BDF_INITIALIZED|BDF_INIT_IN_PROGRESS);
bdev->owning_task=NULL;
LBtr(&bdev->locked_flags,BDlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool PrtUnlock(CPrt *p,Bool rst=FALSE)
{//Release exclusive lock on access to Prt & BlkDev.
PrtChk(p);
if (Bt(&p->locked_flags,Plf_LOCKED) && p->owning_task==Fs) {
BlkDevUnlock(p->bdev,rst);
p->owning_task=NULL;
LBtr(&p->locked_flags,Plf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool BlkDevInit(CBlkDev *bdev)
{
CPrt *p=Drv2Prt(bdev->first_drv_let);
Bool old_preempt=Preempt(OFF),result=FALSE;
if (!LBts(&bdev->flags,BDf_INITIALIZED)) {
bdev->flags|=BDF_INIT_IN_PROGRESS;
switch(bdev->type) {
case BDT_RAM:
if (!bdev->RAM_dsk) {
bdev->RAM_dsk=AMAlloc((bdev->max_blk+1)<<BLK_SIZE_BITS);
bdev->max_blk=MSize(bdev->RAM_dsk)>>BLK_SIZE_BITS-1;
}
p->type=PT_REDSEA;
p->size=bdev->max_blk+1;
if (RedSeaFSDrvValidate(bdev->first_drv_let))
RedSeaFSPrtInit(p);
else
RedSeaFSFmt(bdev->first_drv_let);
result=TRUE;
break;
case BDT_ATA:
bdev->max_reads=128;
bdev->max_writes=1;
result=ATAInit(bdev);
break;
case BDT_ATAPI:
//0xFFFF*4 is too big for my taste
bdev->max_reads=0x800*4;
//max of maybe a quarter of disk cache
if (bdev->max_reads>dsk.cache_size/BLK_SIZE/4)
bdev->max_reads=dsk.cache_size/BLK_SIZE/4 & ~3;
if (bdev->max_reads<128)
bdev->max_reads=128;
bdev->max_writes=0xFFFF*4;
if (result=ATAInit(bdev))
p->size=bdev->max_blk+1;
break;
}
if (result && bdev->flags & BDF_READ_CACHE)
DskCacheInvalidate(p);
bdev->flags&=~BDF_INIT_IN_PROGRESS;
} else
result=TRUE;
Preempt(old_preempt);
return result;
}
U0 BlkDevsRelease()
{//When task dies, release all owned BlkDevs.
I64 i;
CBlkDev *bdev;
for (i=0;i<NUM_BLKDEVS;i++) {
bdev=&dsk.blkdevs[i];
if (bdev->owning_task==Fs && bdev->bd_signature==BD_SIGNATURE_VAL)
BlkDevUnlock(bdev,TRUE);
}
}
U0 PrtsRelease()
{//When task dies, release all owned Prts.
I64 i;
CPrt *p;
for (i=0;i<NUM_PRTS;i++) {
p=&dsk.prts[i];
if (p->owning_task==Fs && p->pt_signature==PRT_SIGNATURE_VAL)
PrtUnlock(p,TRUE);
}
}
CPrt *PrtMakeFree(U8 drv_let)
{//Make a slot free for a new partition, like during $LK,"Mount",A="MN:Mount"$().
//!!! drv_let is not a $LK,"remapped",A="MN:MapDrv"$ prt.
I64 i=ToUpper(drv_let)-'A';
CPrt *result;
if (!(0<=i<NUM_PRTS))
throw('Prt');
result=&dsk.prts[i];
MemSet(result,0,sizeof(CPrt));
result->drv_let='A'+i;
return result;
}
CPrt *PrtNextFree(U8 first_drv_let='C')
{//Locate free slot for new partition, like during $LK,"Mount",A="MN:Mount"$().
//!!! first_drv_let is not a $LK,"remapped",A="MN:MapDrv"$ prt.
I64 i=ToUpper(first_drv_let)-'A';
if (!(0<=i<NUM_PRTS))
throw('Prt');
do
if (dsk.prts[i].pt_signature!=PRT_SIGNATURE_VAL)
return PrtMakeFree(i+'A');
while (++i<NUM_PRTS);
throw('Prt');
return NULL; //never gets here
}
CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
{//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
I64 i=0;
CBlkDev *result;
do {
result=&dsk.blkdevs[i];
if (result->bd_signature!=BD_SIGNATURE_VAL) {
MemSet(result,0,sizeof(CBlkDev));
result->first_drv_let=first_drv_let;
result->type=type;
if (type==BDT_ATAPI)
result->flags=BDF_REMOVABLE;
else
result->flags=0;
if (type!=BDT_RAM)
result->flags|=BDF_READ_CACHE;
if (type==BDT_ATAPI) {
result->blk_size=CD_BLK_SIZE;
result->flags|=BDF_READ_ONLY;
} else
result->blk_size=BLK_SIZE;
result->max_blk=0xEFFFFFFF;
return result;
}
} while (++i<NUM_BLKDEVS);
throw('BlkDev');
return NULL; //never gets here
}
U0 MapBufAlloc(CPrt *p,I64 num_blks)
{
PrtChk(p);
Free(p->cur_map_blk);
Free(p->buffered_map_dirty_bits);
p->num_buffered_map_blks=num_blks;
p->cur_map_blk=AMAlloc(num_blks<<BLK_SIZE_BITS);
p->buffered_map_dirty_bits=ACAlloc((num_blks+7)>>3);
p->cur_map_blk_num=0;
RBlks(p,p->cur_map_blk,p->map1,p->num_buffered_map_blks);
}
U0 CleanMAPBuf(CPrt *p,I64 MAP_select=-1)
{
I64 i;
if ((MAP_select==-1 || !MAP_select) && p->map1!=p->map2)
for (i=0;i<p->num_buffered_map_blks;i++)
if (Bt(p->buffered_map_dirty_bits,i))
WBlks(p,p->cur_map_blk(I64)+i<<BLK_SIZE_BITS,p->map1+i+p->cur_map_blk_num,1);
if (MAP_select==-1 || MAP_select==1 || p->map1==p->map2)
for (i=0;i<p->num_buffered_map_blks;i++)
if (LBtr(p->buffered_map_dirty_bits,i))
WBlks(p,p->cur_map_blk(I64)+i<<BLK_SIZE_BITS,p->map2+i+p->cur_map_blk_num,1);
}
U0 SetFSBuf(CPrt *p,I64 c,I64 map_select=-1)
{
I64 MAP_blk_num;
if (c==INVALID_CLUSTER)
throw('Prt');
if (p->type==PT_FAT32)
MAP_blk_num=c>>(BLK_SIZE_BITS-2);
else
MAP_blk_num=c>>(BLK_SIZE_BITS+3);
if (MAP_blk_num!=p->cur_map_blk_num) {
CleanMAPBuf(p,map_select);
p->cur_map_blk_num=MAP_blk_num;
if (map_select==-1 || !map_select)
RBlks(p,p->cur_map_blk,p->map1+p->cur_map_blk_num,1);
else
RBlks(p,p->cur_map_blk,p->map2+p->cur_map_blk_num,1);
}
}
#define ZERO_BUF_SIZE 2048
U0 WZeroBlks(CPrt *p,I64 blk,I64 cnt)
{//Fill blk cnt with zeros in Prt.
I64 n;
U8 *z=CAlloc(ZERO_BUF_SIZE<<BLK_SIZE_BITS);
Bool show_progress;
if (cnt>ZERO_BUF_SIZE && p->bdev->type!=BDT_RAM) {
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Zeroing");
show_progress=TRUE;
} else
show_progress=FALSE;
while (cnt>0) {
n=cnt;
if (n>ZERO_BUF_SIZE)
n=ZERO_BUF_SIZE;
WBlks(p,z,blk,n);
blk+=n;
cnt-=n;
if (show_progress)
progress1+=n;
Yield; //Prevent locking
}
Free(z);
if (show_progress) {
*progress1_desc=0;
progress1=progress1_max=0;
}
}
Bool SetDrvType(U8 drv_let,I64 type=PT_REDSEA)
{//Very dangerous
I64 i,j,ext_base,prt_num,offset,cur_type;
CMasterBoot mbr;
CBlkDev *bdev=Drv2BlkDev(drv_let);
prt_num=bdev->first_drv_let-'A';
switch (bdev->type) {
case BDT_ATA:
offset=0;
ext_base=INVALID_CLUSTER;
while (TRUE) {
ATAReadBlks(bdev,&mbr,offset,1);
j=-1;
for (i=0;i<4;i++) {
cur_type=mbr.p[i].type;
if (cur_type) {
if (cur_type==5 || cur_type==15)
j=i;
else {
if (prt_num+'A'==ToUpper(drv_let)) {
switch (type) {
case PT_REDSEA:
mbr.p[i].type=MBR_PT_REDSEA;
break;
case PT_FAT32:
mbr.p[i].type=MBR_PT_FAT32a;
break;
default:
Dbg;
}
mbr.p[i].active=0x80;
ATAWriteBlks(bdev,&mbr,offset,1);
return TRUE;
}
prt_num++;
}
}
}
if (j<0)
break;
if (!mbr.p[j].offset)
break;
if (ext_base==INVALID_CLUSTER) {
offset=mbr.p[j].offset;
ext_base=offset;
} else
offset=mbr.p[j].offset+ext_base;
}
break;
}
}
Bool RBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt)
{//Read blk cnt from Prt to buf.
Bool result=TRUE,unlock;
CBlkDev *bdev=p->bdev;
if (cnt<=0) return TRUE;
PrtChk(p);
try {
unlock=PrtLock(p);
BlkDevInit(bdev);
if (p->offset && blk<p->offset || blk+cnt>p->offset+p->size)
throw('Prt');
if (bdev->flags & BDF_READ_CACHE)
RCache(p,&buf,&blk,&cnt);
if (cnt>0) {
switch (bdev->type) {
case BDT_RAM:
MemCpy(buf,bdev->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATARBlks(p,buf,blk,cnt);
break;
}
bdev->last_time=tS;
if (bdev->flags & BDF_READ_CACHE)
DskCacheAdd(p,buf,blk,cnt);
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
return result;
}
Bool WBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt)
{//Write blk cnt from buf to Prt.
Bool result=TRUE,unlock;
CBlkDev *bdev=p->bdev;
if (cnt<=0) return TRUE;
PrtChk(p);
try {
unlock=PrtLock(p);
BlkDevInit(bdev);
if (bdev->flags&BDF_READ_ONLY &&
!(bdev->flags & BDF_READ_ONLY_OVERRIDE))
throw('BlkDev');
if (p->offset && blk<p->offset || blk+cnt>p->offset+p->size)
throw('Prt');
if (cnt>0) {
switch (bdev->type) {
case BDT_RAM:
MemCpy(bdev->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATAWBlks(p,buf,blk,cnt);
break;
}
bdev->last_time=tS;
if (bdev->flags & BDF_READ_CACHE)
DskCacheAdd(p,buf,blk,cnt);
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
return result;
}
U0 DskCacheInvalidate(CPrt *p)
{//Needed for removable media. Called by $LK,"ChgDsk",A="MN:ChgDsk"$().
Bool unlock;
CBlkDev *bdev=p->bdev;
PrtChk(p);
try {
unlock=PrtLock(p);
BlkDevInit(bdev);
if (bdev->flags & BDF_READ_CACHE)
DskCacheInvalidate2(p);
if (p->type==PT_ISO9660) {
if (!(bdev->flags & BDF_READ_ONLY_OVERRIDE))
ISOPrtInit(p,(32767/bdev->blk_size+1)*
bdev->blk_size>>BLK_SIZE_BITS);
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
}
U0 ChgDsk(U8 drv_let=0)
{//Change disk. (Needed for removable media.)
CPrt *p=Drv2Prt(drv_let);
CBlkDev *bdev=p->bdev;
Bool old_preempt=Preempt(OFF);
if (!(bdev->flags&BDF_INITIALIZED))
BlkDevInit(bdev);
else if (bdev->flags&BDF_REMOVABLE)
DskCacheInvalidate(p);
Drv(drv_let);
RedSeaFSFreeFreeLst(p);
Preempt(old_preempt);
}
U8 *DrvSerialNum(U8 drv_let=0)
{//20 bytes max.
CBlkDev *bdev=Drv2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bdev->dev_id_record) {
st=CAlloc(20+1);
for (i=0;i<10;i++)
st[i]=EndianU16(bdev->dev_id_record[10+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U8 *DrvModelNum(U8 drv_let=0)
{//40 bytes max.
CBlkDev *bdev=Drv2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bdev->dev_id_record) {
st=CAlloc(40+1);
for (i=0;i<20;i++)
st[i]=EndianU16(bdev->dev_id_record[27+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U0 PrtRep()
{//Partition report.
CPrt *p;
CBlkDev *bdev;
I64 i,drv_let;
U8 *st;
"\nDefined Partitions:\n\n";
for (i=0,p=dsk.prts;i<NUM_PRTS;i++,p++) {
if (p->pt_signature==PRT_SIGNATURE_VAL) {
bdev=p->bdev;
drv_let=Prt2Drv(p);
if (Bt(&p->type,PTf_DISABLE))
"$$RED$$X";
else if (drv_let==*sys_acct)
"$$GREEN$$:";
else
'' CH_SPACE;
"$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
drv_let,p->type.u16[0],"ST_PRT_TYPES",
bdev->type,"ST_BLKDEV_TYPES",bdev->base0,bdev->base1,bdev->unit;
if (st=DrvModelNum(drv_let)) {
" $$CYAN$$Model# :%s$$FG$$\n",st;
Free(st);
}
if (st=DrvSerialNum(drv_let)) {
" $$CYAN$$Serial#:%s$$FG$$\n",st;
Free(st);
}
" %016X-%016X\n",
p->offset,p->offset+p->size-1;
p->offset,p->offset+p->size-1;
}
}
}
I64 ClusterNumNext(CPrt *p,I64 c,I64 cnt=1)
{//Return next cnt'th cluster in chain.
Bool unlock;
PrtChk(p);
if (cnt<=0) return c;
try {
unlock=PrtLock(p);
switch (p->type) {
case PT_ISO9660:
case PT_REDSEA:
c+=cnt;
break;
case PT_FAT32:
while (cnt-->0 && 0<c<0x0FFFFFF8) {
SetFSBuf(p,c);
c=p->cur_map_blk[c & (BLK_SIZE/4-1)];
}
if (!(0<c<0x0FFFFFF8))
c=INVALID_CLUSTER;
break;
default:
Dbg;
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
return c;
}
I64 Cluster2Blk(CPrt *p,I64 c)
{//Prt cluster num to blk num.
PrtChk(p);
return p->data+c*p->spc;
}
I64 RClustersBlks(CPrt *p,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not read.
I64 i;
Bool unlock;
PrtChk(p);
if (blks<=0) return c;
try {
unlock=PrtLock(p);
switch (p->type) {
case PT_ISO9660:
case PT_REDSEA:
RBlks(p,buf,p->data+c*p->spc,blks);
c+=(blks+p->spc-1)/p->spc;
break;
case PT_FAT32:
while (blks && 0<c<0x0FFFFFF8) {
i=blks;
if (i>p->spc)
i=p->spc;
RBlks(p,buf,p->data+c*p->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(p,c,1);
blks-=i;
}
if (blks)
Dbg;
break;
default:
Dbg;
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
return c;
}
I64 RClusters(CPrt *p,U8 *buf,I64 c,I64 cnt)
{//Read cluster cnt from Prt to buf.
return RClustersBlks(p,buf,c,cnt*p->spc);
}
Bool CFileNameTo(U8 *dst,U8 *src)
{
MemSet(dst,0,CDIR_FILENAME_LEN);
if (!FileNameChk(src))
return FALSE;
StrCpy(dst,src);
return TRUE;
}
I64 Name2DirCluster(CPrt *p,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
PrtChk(p);
try {
unlock=PrtLock(p);
cur_dir_cluster=p->root_cluster;
while (*buf && cont) {
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (p->type) {
case PT_REDSEA:
cont=RedSeaFSFileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case PT_FAT32:
cont=FAT32FileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case PT_ISO9660:
cont=ISO1FileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
Dbg;
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster=0;
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
Free(buf);
Free(buf2);
return cur_dir_cluster;
}
I64 Name2ParentDirCluster(CPrt *p,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster,cur_dir_cluster2;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
PrtChk(p);
try {
unlock=PrtLock(p);
cur_dir_cluster=cur_dir_cluster2=p->root_cluster;
while (*buf && cont) {
cur_dir_cluster2=cur_dir_cluster;
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (p->type) {
case PT_REDSEA:
cont=RedSeaFSFileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case PT_FAT32:
cont=FAT32FileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case PT_ISO9660:
cont=ISO1FileFind(p,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
Dbg;
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster2=0;
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
Free(buf);
Free(buf2);
return cur_dir_cluster2;
}
I64 WClustersBlks(CPrt *p,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not written.
I64 i;
Bool unlock;
PrtChk(p);
if (blks<=0) return c;
try {
unlock=PrtLock(p);
switch (p->type) {
case PT_REDSEA:
WBlks(p,buf,p->data+c*p->spc,blks);
c=0;
break;
case PT_FAT32:
while (blks) {
if (!(0<c<0x0FFFFFF8))
Dbg;
i=blks;
if (i>p->spc)
i=p->spc;
WBlks(p,buf,p->data+c*p->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(p,c);
blks-=i;
}
break;
default:
Dbg;
}
if (unlock)
PrtUnlock(p);
} catch
if (unlock)
PrtUnlock(p);
return c;
}
I64 WClusters(CPrt *p,U8 *buf,I64 c,I64 cnt)
{//Write cluster cnt from buf to Prt.
return WClustersBlks(p,buf,c,cnt*p->spc);
}
I64 ClustersAlloc(CPrt *p,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
{//Alloc cluster cnt into chain.
//c=0 means first cluster in chain
PrtChk(p);
if (cnt<=0) return c;
switch (p->type) {
case PT_REDSEA:
return RedSeaFSAllocClusters(p,cnt);
case PT_FAT32:
if (contiguous) {
if (c) throw('File');
return FAT32AllocContiguousClusters(p,cnt);
} else
return FAT32AllocClusters(p,c,cnt);
default:
Dbg;
}
}
Kernel/Dsk/DskA.CPP
+731
View File
@@ -0,0 +1,731 @@
Bool BlkDevLock(CBlkDev *bd)
{//Make this task have exclusive access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (!Bt(&bd->locked_flags,BDlf_LOCKED) || bd->owning_task!=Fs) {
while (LBts(&bd->locked_flags,BDlf_LOCKED))
Yield;
bd->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool DrvLock(CDrv *dv)
{//Make this task have exclusive access to drv & BlkDev.
DrvChk(dv);
BlkDevLock(dv->bd);
if (!Bt(&dv->locked_flags,DVlf_LOCKED) || dv->owning_task!=Fs) {
while (LBts(&dv->locked_flags,DVlf_LOCKED))
Yield;
dv->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE)
{//Release exclusive lock on access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (Bt(&bd->locked_flags,BDlf_LOCKED) && bd->owning_task==Fs) {
if (rst)
bd->flags&=~(BDF_INITIALIZED|BDF_INIT_IN_PROGRESS);
bd->owning_task=NULL;
LBtr(&bd->locked_flags,BDlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool DrvUnlock(CDrv *dv,Bool rst=FALSE)
{//Release exclusive lock on access to drv & BlkDev.
DrvChk(dv);
if (Bt(&dv->locked_flags,DVlf_LOCKED) && dv->owning_task==Fs) {
BlkDevUnlock(dv->bd,rst);
dv->owning_task=NULL;
LBtr(&dv->locked_flags,DVlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool BlkDevInit(CBlkDev *bd)
{
CDrv *dv=Let2Drv(bd->first_drv_let);
Bool old_preempt=Preempt(OFF),result=FALSE;
if (!LBts(&bd->flags,BDf_INITIALIZED)) {
bd->flags|=BDF_INIT_IN_PROGRESS;
switch(bd->type) {
case BDT_RAM:
if (!bd->RAM_dsk) {
bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
}
dv->type=DVT_REDSEA;
dv->size=bd->max_blk+1;
if (RedSeaDrvValidate(bd->first_drv_let))
RedSeaDrvInit(dv);
else
RedSeaFmt(bd->first_drv_let);
result=TRUE;
break;
case BDT_ATA:
bd->max_reads=128;
bd->max_writes=1;
result=ATAInit(bd);
break;
case BDT_ATAPI:
//0xFFFF*4 is too big for my taste
bd->max_reads=0x800*4;
//max of maybe a quarter of disk cache
if (bd->max_reads>dsk.cache_size/BLK_SIZE/4)
bd->max_reads=dsk.cache_size/BLK_SIZE/4 & ~3;
if (bd->max_reads<128)
bd->max_reads=128;
bd->max_writes=0xFFFF*4;
if (result=ATAInit(bd))
dv->size=bd->max_blk+1;
break;
}
if (result && bd->flags & BDF_READ_CACHE)
DskCacheInvalidate(dv);
bd->flags&=~BDF_INIT_IN_PROGRESS;
} else
result=TRUE;
Preempt(old_preempt);
return result;
}
U0 BlkDevsRelease()
{//When task dies, release all owned BlkDevs.
I64 i;
CBlkDev *bd;
for (i=0;i<NUM_BLKDEVS;i++) {
bd=&dsk.blkdevs[i];
if (bd->owning_task==Fs && bd->bd_signature==BD_SIGNATURE_VAL)
BlkDevUnlock(bd,TRUE);
}
}
U0 DrvsRelease()
{//When task dies, release all owned drvs.
I64 i;
CDrv *dv;
for (i=0;i<NUM_DRVS;i++) {
dv=&dsk.drvs[i];
if (dv->owning_task==Fs && dv->dv_signature==DRV_SIGNATURE_VAL)
DrvUnlock(dv,TRUE);
}
}
CDrv *DrvMakeFree(U8 drv_let)
{//Make a slot free for a new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(drv_let)-'A';
CDrv *result;
if (!(0<=i<NUM_DRVS))
throw('Drv');
result=&dsk.drvs[i];
MemSet(result,0,sizeof(CDrv));
result->drv_let='A'+i;
return result;
}
CDrv *DrvNextFree(U8 first_drv_let='C')
{//Locate free slot for new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! first_drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(first_drv_let)-'A';
if (!(0<=i<NUM_DRVS))
throw('Drv');
do
if (dsk.drvs[i].dv_signature!=DRV_SIGNATURE_VAL)
return DrvMakeFree(i+'A');
while (++i<NUM_DRVS);
throw('Drv');
return NULL; //never gets here
}
CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
{//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
I64 i=0;
CBlkDev *result;
do {
result=&dsk.blkdevs[i];
if (result->bd_signature!=BD_SIGNATURE_VAL) {
MemSet(result,0,sizeof(CBlkDev));
result->first_drv_let=first_drv_let;
result->type=type;
if (type==BDT_ATAPI)
result->flags=BDF_REMOVABLE;
else
result->flags=0;
if (type!=BDT_RAM)
result->flags|=BDF_READ_CACHE;
if (type==BDT_ATAPI) {
result->blk_size=CD_BLK_SIZE;
result->flags|=BDF_READ_ONLY;
} else
result->blk_size=BLK_SIZE;
result->max_blk=0xEFFFFFFF;
return result;
}
} while (++i<NUM_BLKDEVS);
throw('BlkDev');
return NULL; //never gets here
}
U0 DrvMapBlkAlloc(CDrv *dv)
{
DrvChk(dv);
Free(dv->cur_map_blk);
dv->cur_map_blk=AMAlloc(BLK_SIZE);
dv->cur_map_blk_num=0;
dv->map_blk_dirty=0;
RBlks(dv,dv->cur_map_blk,dv->map1,1);
}
U0 DrvMapBlkClean(CDrv *dv,I64 map_select=3)
{
if (dv->type==DVT_FAT32 || dv->type==DVT_REDSEA) {
if ((map_select==3 || !map_select) && dv->map1!=dv->map2 &&
Bt(&dv->map_blk_dirty,0))
WBlks(dv,dv->cur_map_blk(I64),dv->map1+dv->cur_map_blk_num,1);
if (map_select==3 || map_select==1 || dv->map1==dv->map2 &&
LBtr(&dv->map_blk_dirty,0))
WBlks(dv,dv->cur_map_blk(I64),dv->map2+dv->cur_map_blk_num,1);
}
}
U0 DrvMapBlkSet(CDrv *dv,I64 c,I64 map_select=3)
{
I64 map_blk_num;
if (c==INVALID_CLUSTER)
throw('Drv');
switch (dv->type) {
case DVT_FAT32:
map_blk_num=c>>(BLK_SIZE_BITS-2);
break;
case DVT_REDSEA:
map_blk_num=(c-dv->data_area)>>(BLK_SIZE_BITS+3);
break;
default:
throw('Drv');
}
if (map_blk_num!=dv->cur_map_blk_num) {
DrvMapBlkClean(dv,map_select);
dv->cur_map_blk_num=map_blk_num;
if (map_select==3 || !map_select)
RBlks(dv,dv->cur_map_blk,dv->map1+dv->cur_map_blk_num,1);
else
RBlks(dv,dv->cur_map_blk,dv->map2+dv->cur_map_blk_num,1);
}
}
#define ZERO_BUF_SIZE 2048
U0 WZeroBlks(CDrv *dv,I64 blk,I64 cnt)
{//Fill blk cnt with zeros in Drv.
I64 n;
U8 *z=CAlloc(ZERO_BUF_SIZE<<BLK_SIZE_BITS);
Bool show_progress;
if (cnt>ZERO_BUF_SIZE && dv->bd->type!=BDT_RAM) {
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Zeroing");
show_progress=TRUE;
} else
show_progress=FALSE;
while (cnt>0) {
n=cnt;
if (n>ZERO_BUF_SIZE)
n=ZERO_BUF_SIZE;
WBlks(dv,z,blk,n);
blk+=n;
cnt-=n;
if (show_progress)
progress1+=n;
Yield; //Prevent locking
}
Free(z);
if (show_progress) {
*progress1_desc=0;
progress1=progress1_max=0;
}
}
Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
{//Very dangerous
I64 i,j,ext_base,drv_num,offset,cur_type;
CMasterBoot mbr;
CBlkDev *bd=Let2BlkDev(drv_let);
drv_num=bd->first_drv_let-'A';
switch (bd->type) {
case BDT_ATA:
offset=0;
ext_base=INVALID_CLUSTER;
while (TRUE) {
ATAReadBlks(bd,&mbr,offset,1);
j=-1;
for (i=0;i<4;i++) {
cur_type=mbr.p[i].type;
if (cur_type) {
if (cur_type==5 || cur_type==15)
j=i;
else {
if (drv_num+'A'==ToUpper(drv_let)) {
switch (type) {
case DVT_REDSEA:
mbr.p[i].type=MBR_PT_REDSEA;
break;
case DVT_FAT32:
mbr.p[i].type=MBR_PT_FAT32a;
break;
default:
throw('Drv');
}
mbr.p[i].active=0x80;
ATAWriteBlks(bd,&mbr,offset,1);
return TRUE;
}
drv_num++;
}
}
}
if (j<0)
break;
if (!mbr.p[j].offset)
break;
if (ext_base==INVALID_CLUSTER) {
offset=mbr.p[j].offset;
ext_base=offset;
} else
offset=mbr.p[j].offset+ext_base;
}
break;
}
}
Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Read blk cnt from Drv to buf.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (dv->base_offset && blk<dv->base_offset || blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (bd->flags & BDF_READ_CACHE)
RCache(dv,&buf,&blk,&cnt);
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(buf,bd->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATARBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Write blk cnt from buf to Drv.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags&BDF_READ_ONLY && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
throw('BlkDev');
if (dv->base_offset && blk<dv->base_offset || blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(bd->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATAWBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
U0 DskCacheInvalidate(CDrv *dv)
{//Needed for removable media. Called by $LK,"ChgDsk",A="MN:ChgDsk"$().
Bool unlock;
CBlkDev *bd=dv->bd;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags & BDF_READ_CACHE)
DskCacheInvalidate2(dv);
if (dv->type==DVT_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
}
U0 ChgDsk(U8 drv_let=0)
{//Change disk. (Needed for removable media.)
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
Bool old_preempt=Preempt(OFF);
if (!(bd->flags&BDF_INITIALIZED))
BlkDevInit(bd);
else if (bd->flags&BDF_REMOVABLE)
DskCacheInvalidate(dv);
Drv(drv_let);
RedSeaFreeFreeLst(dv);
Preempt(old_preempt);
}
U8 *DrvSerialNum(U8 drv_let=0)
{//20 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(20+1);
for (i=0;i<10;i++)
st[i]=EndianU16(bd->dev_id_record[10+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U8 *DrvModelNum(U8 drv_let=0)
{//40 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(40+1);
for (i=0;i<20;i++)
st[i]=EndianU16(bd->dev_id_record[27+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U0 DrvRep()
{//Drive report.
CDrv *dv;
CBlkDev *bd;
I64 i,drv_let;
U8 *st;
"\nDefined Drives:\n\n";
for (i=0,dv=dsk.drvs;i<NUM_DRVS;i++,dv++) {
if (dv->dv_signature==DRV_SIGNATURE_VAL) {
bd=dv->bd;
drv_let=Drv2Let(dv);
if (Bt(&dv->type,DVTf_DISABLE))
"$$RED$$X";
else if (drv_let==dsk.boot_drv_let)
"$$GREEN$$:";
else
'' CH_SPACE;
"$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
drv_let,dv->type.u16[0],"ST_DRV_TYPES",
bd->type,"ST_BLKDEV_TYPES",bd->base0,bd->base1,bd->unit;
if (st=DrvModelNum(drv_let)) {
" $$CYAN$$Model# :%s$$FG$$\n",st;
Free(st);
}
if (st=DrvSerialNum(drv_let)) {
" $$CYAN$$Serial#:%s$$FG$$\n",st;
Free(st);
}
" %016X-%016X\n",
dv->base_offset,dv->base_offset+dv->size-1;
dv->base_offset,dv->base_offset+dv->size-1;
}
}
}
I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
{//Return next cnt'th cluster in chain.
Bool unlock;
DrvChk(dv);
if (cnt<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
case DVT_REDSEA:
c+=cnt;
break;
case DVT_FAT32:
while (cnt-->0 && 0<c<0x0FFFFFF8) {
DrvMapBlkSet(dv,c);
c=dv->cur_map_blk[c & (BLK_SIZE/4-1)];
}
if (!(0<c<0x0FFFFFF8))
c=INVALID_CLUSTER;
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 Cluster2Blk(CDrv *dv,I64 c)
{//Drv cluster num to blk num.
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
return c;
case DVT_ISO9660:
case DVT_FAT32:
return dv->data_area+c*dv->spc;
default:
throw('Drv');
}
}
I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not read.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
RBlks(dv,buf,dv->data_area+c*dv->spc,blks);
c+=(blks+dv->spc-1)/dv->spc;
break;
case DVT_REDSEA:
RBlks(dv,buf,c,blks);
c+=blks;
break;
case DVT_FAT32:
while (blks && 0<c<0x0FFFFFF8) {
i=blks;
if (i>dv->spc)
i=dv->spc;
RBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c,1);
blks-=i;
}
if (blks)
throw('Drv');
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 RClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Read cluster cnt from drv to buf.
return RClustersBlks(dv,buf,c,cnt*dv->spc);
}
Bool CFileNameTo(U8 *dst,U8 *src)
{
MemSet(dst,0,CDIR_FILENAME_LEN);
if (!FileNameChk(src))
return FALSE;
StrCpy(dst,src);
return TRUE;
}
I64 Name2DirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=dv->root_cluster;
while (*buf && cont) {
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster;
}
I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster,cur_dir_cluster2;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=cur_dir_cluster2=dv->root_cluster;
while (*buf && cont) {
cur_dir_cluster2=cur_dir_cluster;
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster2=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster2;
}
I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not written.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_REDSEA:
WBlks(dv,buf,c,blks);
c=0;
break;
case DVT_FAT32:
while (blks) {
if (!(0<c<0x0FFFFFF8))
throw('Drv');
i=blks;
if (i>dv->spc)
i=dv->spc;
WBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c);
blks-=i;
}
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 WClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Write cluster cnt from buf to drv.
return WClustersBlks(dv,buf,c,cnt*dv->spc);
}
I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
{//Alloc cluster cnt into chain.
//c=0 means first cluster in chain
DrvChk(dv);
if (cnt<=0) return c;
switch (dv->type) {
case DVT_REDSEA:
return RedSeaAllocClusters(dv,cnt);
case DVT_FAT32:
if (contiguous) {
if (c) throw('File');
return FAT32AllocContiguousClusters(dv,cnt);
} else
return FAT32AllocClusters(dv,c,cnt);
default:
throw('Drv');
}
}
Kernel/Dsk/DskATA.CPP
+287 -568
View File
File diff suppressed because it is too large. Load diff
Kernel/Dsk/DskATAId.CPP
+279
View File
@@ -0,0 +1,279 @@
Bool BootCdProbe(CBlkDev *bd)
{
CKernel *img=CAlloc(CD_BLK_SIZE);
I64 i;
Bool result=FALSE;
"Port: %04X,%04X Unit: %02X ",bd->base0,bd->base1,bd->unit;
if (ATAProbe(bd->base0,bd->base1,bd->unit)==BDT_ATAPI) {
" ATAPI";
if (ATAPIStartStop(bd,tS+5.0,TRUE)) {
" Started";
for (i=0;i<2;i++) {//Retry
if (ATAPIReadBlks2(bd,tS+7.0,img,sys_boot_src.u16[1],1,FALSE)) {
if (img->compile_time==sys_compile_time) {
" Found";
return TRUE;
} else
" Read";
} else
" NoRead";
}
}
}
" Nope\n";
Free(img);
return result;
}
Bool BootCdProbeAll(CBlkDev *bd)
{
I64 d1,d2,i,j,k;
bd->base1=0;
for (k=0;k<256;k++) {
i=-1;
while (TRUE) {
j=PCIClassFind(0x010100+k,++i);
if (j<0)
break;
"Subcode:0x%X Bus:0x%X Dev:0x%X Fun:0x%X\n",k,j.u8[2],j.u8[1],j.u8[0];
d1=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x10);
d2=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x14);
if (d1&1 && d2&1) {
if (bd->base0=d1&~7) {
bd->unit=0;
if (BootCdProbe(bd))
return TRUE;
bd->unit=1;
if (BootCdProbe(bd))
return TRUE;
}
}
d1=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x18);
d2=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x1C);
if (d1&1 && d2&1) {
if (bd->base0=d1&~7) {
bd->unit=0;
if (BootCdProbe(bd))
return TRUE;
bd->unit=1;
if (BootCdProbe(bd))
return TRUE;
}
}
}
}
d1=0x1F0;
d2=0x3F6;
if (bd->base0=d1&~7) {
bd->unit=0;
if (BootCdProbe(bd))
return TRUE;
bd->unit=1;
if (BootCdProbe(bd))
return TRUE;
}
d1=0x170;
d2=0x376;
if (bd->base0=d1&~7) {
bd->unit=0;
if (BootCdProbe(bd))
return TRUE;
bd->unit=1;
if (BootCdProbe(bd))
return TRUE;
}
}
U0 ATARepEntry(I64 base0,I64 base1,I64 unit,I64 irq,U8 *msg,CATARep **_root,I64 *num_hints)
{
I64 type;
base0&=-8;
base1&=-4;
CATARep *tempha;
if (type=ATAProbe(base0,base1,unit)) {
*num_hints+=1;
"\n\n$$PURPLE$$ $$BT+X,\"%d\",LM=\"%d\\n\"$$$$FG$$$$LM,4$$",*num_hints,*num_hints;
if (type==BDT_ATA)
"$$RED$$ATA ";
else
"$$RED$$ATAPI ";
"$$LTBLUE$$%s$$FG$$\nBase0:0x%04X Base1:0x%04X\nIrq:0x%02X Unit:%d$$LM,0$$\n",msg,base0,base1,irq,unit;
if (_root) {
tempha=CAlloc(sizeof(CATARep));
tempha->next=*_root;
*_root=tempha;
tempha->num=*num_hints;
tempha->type=type;
tempha->base0=base0;
tempha->base1=base1;
tempha->unit=unit;
}
}
}
Bool ATARepExitAllApplications()
{
"\nWe're going to probe hardware.\n"
"$$RED$$Exit all other applications.$$FG$$\n"
"Press '$$PURPLE$$p$$FG$$' to probe or '$$PURPLE$$s$$FG$$' to skip.\n";
if (ToUpper(GetChar(,FALSE))=='S')
return TRUE;
else
return FALSE;
}
public I64 ATARep(Bool pmt=TRUE,Bool just_ide=FALSE,CATARep **_root=NULL)
{//Report possible ATA devices by probing. Hard disks and CD/DVDs.
I64 d1,d2,d3,i,j,k,cnt=0,unlock_flags=0,num_hints=0;
#assert NUM_BLKDEVS<=64
Bool old_preempt;
if (_root) *_root=NULL;
if (pmt && ATARepExitAllApplications)
return 0;
old_preempt=Preempt(OFF);
for (i=0;i<NUM_BLKDEVS;i++)
if (dsk.blkdevs[i].bd_signature==BD_SIGNATURE_VAL)
BEqu(&unlock_flags,i,
BlkDevLock(&dsk.blkdevs[i]));
if (!just_ide)
for (k=0;k<256;k++) {
i=-1;
while (TRUE) {
j=PCIClassFind(0x010100+k,++i);
if (j<0)
break;
"\nSubcode:0x%X Bus:0x%X Dev:0x%X Fun:0x%X\n",k,j.u8[2],j.u8[1],j.u8[0];
cnt++;
d1=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x10);
d2=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x14);
d3=PCIReadU8(j.u8[2],j.u8[1],j.u8[0],0x3C);
if (d1&1 && d2&1) {
ATARepEntry(d1,d2,0,d3,"Primary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Primary IDE",_root,&num_hints);
} else {
d1=0x1F0; d2=0x3F6; d3=14;
ATARepEntry(d1,d2,0,d3,"Primary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Primary IDE",_root,&num_hints);
}
d1=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x18);
d2=PCIReadU32(j.u8[2],j.u8[1],j.u8[0],0x1C);
if (d1&1 && d2&1) {
ATARepEntry(d1,d2,0,d3,"Secondary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Secondary IDE",_root,&num_hints);
} else {
d1=0x170; d2=0x376; d3=15;
ATARepEntry(d1,d2,0,d3,"Secondary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Secondary IDE",_root,&num_hints);
}
}
}
if (!cnt) {
d1=0x1F0; d2=0x3F6; d3=14;
ATARepEntry(d1,d2,0,d3,"Primary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Primary IDE",_root,&num_hints);
d1=0x170; d2=0x376; d3=15;
ATARepEntry(d1,d2,0,d3,"Secondary IDE",_root,&num_hints);
ATARepEntry(d1,d2,1,d3,"Secondary IDE",_root,&num_hints);
}
'\n\n';
for (i=0;i<NUM_BLKDEVS;i++)
if (Bt(&unlock_flags,i))
BlkDevUnlock(&dsk.blkdevs[i]);
Preempt(old_preempt);
return num_hints;
}
CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv)
{//This is for when trying to sort-out main hard drives and CD-ROM drives.
CATARep *result=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
CBlkDev *bd;
Bool was_silent=Silent;
try
bd=Let2BlkDev(_sys_boot_drv);
catch {
Fs->catch_except=TRUE;
bd=NULL;
}
Silent(was_silent);
while (tempha) {
if (!result && bd && bd->type==tempha->type) {
if (bd->type==BDT_ATAPI &&
bd->base0==tempha->base0 && bd->unit==tempha->unit)
result=atapi_drv=tempha;
else if (bd->type==BDT_ATA && bd->base0==tempha->base0 &&
bd->base1==tempha->base1 && bd->unit==tempha->unit)
result=ata_drv=tempha;
}
if (!result || result->type!=tempha->type) {
if (tempha->type==BDT_ATA) {
if (!ata_drv || tempha->unit<ata_drv->unit ||
tempha->unit==ata_drv->unit && tempha->num<ata_drv->num)
ata_drv=tempha;
} else if (tempha->type==BDT_ATAPI) {
if (!atapi_drv || tempha->unit<atapi_drv->unit ||
tempha->unit==atapi_drv->unit && tempha->num<atapi_drv->num)
atapi_drv=tempha;
}
}
tempha=tempha->next;
}
if (_ata_drv) *_ata_drv =ata_drv;
if (_atapi_drv) *_atapi_drv=atapi_drv;
return result;
}
CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit)
{
CBlkDev *result;
if (0<=first_drv_let-'A'<NUM_DRVS && (type==BDT_ATA || type==BDT_ATAPI) &&
0<=unit<=1) {
result=BlkDevNextFree(first_drv_let,type);
result->unit=unit;
result->base0=base0;
result->base1=base1;
if (BlkDevAdd(result,FALSE,FALSE))
return result;
}
return NULL;
}
I64 AutoMountIDE()
{//Try to mount hard drive and CD/DVD, automatically. (Kernel.Cfg option).
//It uses 'C' and 'T' as first drive letters or whatever you set
//in config when compiling Kernel.BIN.
I64 result=0;
CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL,*tempha;
ATARep(FALSE,TRUE,&root);
ATAIDDrvs(root,dsk.boot_drv_let,&ata_drv,&atapi_drv);
if (ata_drv && ATAMount(dsk.first_hd_drv_let,BDT_ATA,
ata_drv->base0,ata_drv->base1,ata_drv->unit))
result++;
if (atapi_drv && ATAMount(dsk.first_cd_drv_let,BDT_ATAPI,
atapi_drv->base0,atapi_drv->base1,atapi_drv->unit))
result++;
tempha=root;
while (tempha) {
if (tempha!=ata_drv && tempha!=atapi_drv) {
if (tempha->type==BDT_ATA && ATAMount(dsk.first_hd_drv_let,BDT_ATA,
tempha->base0,tempha->base1,tempha->unit))
result++;
else if (tempha->type==BDT_ATAPI && ATAMount(dsk.first_cd_drv_let,BDT_ATAPI,
tempha->base0,tempha->base1,tempha->unit))
result++;
}
tempha=tempha->next;
}
LinkedLstDel(root);
dsk.auto_mount_ide_cnt=result;
return result;
}
Kernel/Dsk/DskAddDev.CPP
+88 -87
View File
@@ -1,18 +1,18 @@
U0 SetBlkDevLockFwding(CBlkDev *bdev)
{
CBlkDev *bdev1;
U0 BlkDevLockFwdingSet(CBlkDev *bd)
{ //If two blkdevs on same controller, use just one lock
CBlkDev *bd1;
I64 i;
switch (bdev->type) {
switch (bd->type) {
case BDT_RAM:
break;
case BDT_ATA:
case BDT_ATAPI:
for (i=0;i<NUM_BLKDEVS;i++) {
bdev1=&dsk.blkdevs[i];
if (bdev1->bd_signature==BD_SIGNATURE_VAL && bdev!=bdev1 &&
(bdev1->type==BDT_ATAPI || bdev1->type==BDT_ATA) &&
bdev1->base0==bdev->base0) {
bdev->lock_fwding=bdev1;
bd1=&dsk.blkdevs[i];
if (bd1->bd_signature==BD_SIGNATURE_VAL && bd!=bd1 &&
(bd1->type==BDT_ATAPI || bd1->type==BDT_ATA) &&
bd1->base0==bd->base0) {
bd->lock_fwding=bd1;
break;
}
}
@@ -20,74 +20,74 @@ U0 SetBlkDevLockFwding(CBlkDev *bdev)
}
}
I64 BlkDevAdd(CBlkDev *bdev,Bool one_prt,Bool make_free)
I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
{
I64 i,j,ext_base,offset,result=0;
CPrt *p;
CBootStruct br;
CDrv *dv;
CRedSeaBoot br;
CMasterBoot mbr;
bdev->bd_signature=BD_SIGNATURE_VAL;
bd->bd_signature=BD_SIGNATURE_VAL;
if (make_free)
p=PrtMakeFree(bdev->first_drv_let+result);
dv=DrvMakeFree(bd->first_drv_let+result);
else
p=PrtNextFree(bdev->first_drv_let+result);
p->bdev=bdev;
p->size=bdev->max_blk+1;
switch (bdev->type) {
dv=DrvNextFree(bd->first_drv_let+result);
dv->bd=bd;
dv->size=bd->max_blk+1;
switch (bd->type) {
case BDT_RAM:
p->pt_signature=PRT_SIGNATURE_VAL;
p->type=PT_REDSEA;
dv->dv_signature=DRV_SIGNATURE_VAL;
dv->type=DVT_REDSEA;
//This is to force creation of a RAM
//drive during boot, so it is probably
//MAlloced to the same addr and can
//be assumed to be already formatted.
//If this line is removed, RAM Drives
//will be allocated on a just-in-time
//will be alloced on a just-in-time
//basis.
if (BlkDevInit(bdev))
if (BlkDevInit(bd))
result++;
else
p->pt_signature=0;
dv->dv_signature=0;
break;
case BDT_ATA:
p->pt_signature=PRT_SIGNATURE_VAL; //Temporarily validate
if (!BlkDevInit(bdev))
p->pt_signature=0; //Revoke validation
dv->dv_signature=DRV_SIGNATURE_VAL; //Temporarily validate
if (!BlkDevInit(bd))
dv->dv_signature=0; //Revoke validation
else {
p->pt_signature=0; //Revoke validation
if (one_prt) {
p->pt_signature=PRT_SIGNATURE_VAL;
dv->dv_signature=0; //Revoke validation
if (one_drv) {
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
p->type=PT_REDSEA;
p->size=bdev->max_blk+1;
dv->type=DVT_REDSEA;
dv->size=bd->max_blk+1;
//The following read is a test read.
//if it hangs, the drive is not supported.
ATAReadBlks(bdev,&mbr,0,1);
ATAReadBlks(bd,&mbr,0,1);
break;
}
offset=0;
ext_base=INVALID_CLUSTER;
while (TRUE) {
ATAReadBlks(bdev,&mbr,offset,1);
ATAReadBlks(bd,&mbr,offset,1);
if (mbr.signature!=0xAA55)
break;
j=-1;
for (i=0;i<4;i++) {
if (mbr.p[i].type) {
if (make_free)
p=PrtMakeFree(bdev->first_drv_let+result);
dv=DrvMakeFree(bd->first_drv_let+result);
else
p=PrtNextFree(bdev->first_drv_let+result);
p->bdev=bdev;
p->offset=mbr.p[i].offset+offset;
p->size =mbr.p[i].size;
dv=DrvNextFree(bd->first_drv_let+result);
dv->bd=bd;
dv->base_offset=mbr.p[i].offset+offset;
dv->size =mbr.p[i].size;
switch (mbr.p[i].type) {
case MBR_PT_REDSEA:
p->pt_signature=PRT_SIGNATURE_VAL;
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
p->type=PT_REDSEA;
RedSeaFSPrtInit(p);
dv->type=DVT_REDSEA;
RedSeaDrvInit(dv);
break;
case MBR_PT_FAT32a:
case MBR_PT_FAT32b:
@@ -95,30 +95,30 @@ I64 BlkDevAdd(CBlkDev *bdev,Bool one_prt,Bool make_free)
case MBR_PT_FAT32d:
case MBR_PT_FAT32e:
case MBR_PT_FAT32f:
ATAReadBlks(bdev,&br,p->offset,1);
p->pt_signature=PRT_SIGNATURE_VAL;
ATAReadBlks(bd,&br,dv->base_offset,1);
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
if (br.signature==MBR_PT_REDSEA) {
p->type=PT_REDSEA;
RedSeaFSPrtInit(p);
dv->type=DVT_REDSEA;
RedSeaDrvInit(dv);
} else {
p->type=PT_FAT32;
FAT32PrtInit(p);
dv->type=DVT_FAT32;
FAT32DrvInit(dv);
}
break;
case MBR_PT_NTFS:
p->pt_signature=PRT_SIGNATURE_VAL;
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
p->type=PT_NTFS;
dv->type=DVT_NTFS;
break;
case 5:
case 15:
j=i;
break;
default:
p->pt_signature=PRT_SIGNATURE_VAL;
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
p->type=PT_UNKNOWN;
dv->type=DVT_UNKNOWN;
}
}
}
@@ -135,26 +135,26 @@ I64 BlkDevAdd(CBlkDev *bdev,Bool one_prt,Bool make_free)
}
break;
case BDT_ATAPI:
p->pt_signature=PRT_SIGNATURE_VAL;
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
p->type=PT_ISO9660; //Start with this
p->size =0;
dv->type=DVT_ISO9660; //Start with this
dv->size =0;
break;
}
if (result)
SetBlkDevLockFwding(bdev);
BlkDevLockFwdingSet(bd);
else
MemSet(bdev,0,sizeof(CBlkDev));
MemSet(bd,0,sizeof(CBlkDev));
return result;
}
Bool DrvEnable(U8 drv_let,Bool val)
{//Can unmount or remount, but not mount the first time.
CPrt *p;
CDrv *dv;
Bool result=FALSE;
try {
p=Drv2Prt(drv_let);
result=!LBEqu(&p->type,PTf_DISABLE,!val);
dv=Let2Drv(drv_let);
result=!LBEqu(&dv->type,DVTf_DISABLE,!val);
} catch
Fs->catch_except=TRUE;
return result;
@@ -172,14 +172,14 @@ CATARep *ATARepFind(CATARep *haystack_root,I64 needle_num)
U0 Mount(Bool repartition=FALSE)
{//Mount a drive.
CBlkDev *bdev;
I64 first_prt_num,type,unit,num_hints;
CBlkDev *bd;
I64 first_drv_num,type,unit,num_hints;
U8 blks_buf[128],addr_buf[128],base0_buf[128],base1_buf[128];
Bool add;
CATARep *root,*tempha;
do {
PrtRep;
DrvRep;
"\n****** Mount Drives ******\n"
"The first drive letter is the letter\n"
"of the first partition. If adding\n"
@@ -187,9 +187,9 @@ U0 Mount(Bool repartition=FALSE)
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
first_prt_num=ToUpper(GetChar)-'A';
first_drv_num=ToUpper(GetChar)-'A';
'\n';
if (0<=first_prt_num<NUM_PRTS) {
if (0<=first_drv_num<NUM_DRVS) {
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
type=GetChar-'0';
@@ -235,35 +235,35 @@ U0 Mount(Bool repartition=FALSE)
}
if (BDT_NULL<type<BDT_NUM_TYPES && 0<=unit<=1) {
bdev=BlkDevNextFree(first_prt_num+'A',type);
bdev->unit=unit;
bd=BlkDevNextFree(first_drv_num+'A',type);
bd->unit=unit;
if (type==BDT_RAM) {
if (!*addr_buf) StrCpy(addr_buf,"0");
bdev->RAM_dsk=Str2I64(addr_buf);
bdev->max_blk=Str2I64(blks_buf)-1;
bd->RAM_dsk=Str2I64(addr_buf);
bd->max_blk=Str2I64(blks_buf)-1;
}
if (type==BDT_ATA ||
type==BDT_ATAPI) {
bdev->base0=Str2I64(base0_buf);
bdev->base1=Str2I64(base1_buf);
bd->base0=Str2I64(base0_buf);
bd->base1=Str2I64(base1_buf);
}
add=TRUE;
if (type==BDT_ATA && repartition) {
"\nReformat WHOLE drive!";
if (YorN) {
if (!BlkDevAdd(bdev,TRUE,TRUE))
if (!BlkDevAdd(bd,TRUE,TRUE))
"\n\n$$BK,1$$$$RED$$Operation Failed$$BK,0$$$$FG$$\n\n";
else
CallExtStr("PrtDsk",bdev->first_drv_let);
CallExtStr("PrtDsk",bd->first_drv_let);
add=FALSE;
}
}
if (add && !BlkDevAdd(bdev,FALSE,TRUE))
if (add && !BlkDevAdd(bd,FALSE,TRUE))
"\n\n$$BK,1$$$$RED$$Operation Failed$$BK,0$$$$FG$$\n\n";
} else
"\n\n$$BK,1$$$$RED$$Operation Failed$$BK,0$$$$FG$$\n\n";
}
} while (0<=first_prt_num<NUM_PRTS);
} while (0<=first_drv_num<NUM_DRVS);
}
I64 SysGetI64()
@@ -273,7 +273,7 @@ I64 SysGetI64()
return Str2I64(st,16);
}
Bool GetBaseUnit(CBlkDev *bdev)
Bool GetBaseUnit(CBlkDev *bd)
{
I64 ch;
Bool probe;
@@ -284,25 +284,26 @@ Bool GetBaseUnit(CBlkDev *bdev)
else
StreamPrint("probe=TRUE;");
};
if (!probe || !BootCdProbeAll(bdev)) {
if (!probe || !BootCdProbeAll(bd)) {
"\nDon't worry. This is not a product\n"
"registration. TempleOS just needs the\n"
"I/O port numbers for the CD-ROM.\n"
"\nRetry the ports above or check Windows\n"
"system information under I/O ports for\n"
"'IDE', 'ATA' or 'SATA'.\n"
"In Linux, use 'lspci -v' for ports.\n"
"\n\nEnter 4-digit hex I/O Port number.\n"
"CD-ROM I/O Port Base0: 0x";
bdev->base0=SysGetI64;
bdev->base1=0;
bdev->unit =0;
if (bdev->base0) {
bd->base0=SysGetI64;
bd->base1=0;
bd->unit =0;
if (bd->base0) {
"\nUnit (0 or 1): ";
do ch=GetChar(,FALSE);
while (!('0'<=ch<='1'));
'' ch;
bdev->unit=ch-'0';
dsk.cdrom_boot_is_good=BootCdProbe(bdev);
bd->unit=ch-'0';
dsk.cdrom_boot_is_good=BootCdProbe(bd);
return TRUE;
} else {
dsk.cdrom_boot_is_good=FALSE;
@@ -314,12 +315,12 @@ Bool GetBaseUnit(CBlkDev *bdev)
U0 BlkDevsInitAll()
{
CBlkDev *bdev;
CBlkDev *bd;
I64 i;
dsk.blkdevs=CAlloc(sizeof(CBlkDev)*NUM_BLKDEVS);
dsk.prts=CAlloc(sizeof(CPrt)*NUM_PRTS);
for (i=0;i<NUM_PRTS;i++)
dsk.drv_to_prt[i]=&dsk.prts[i];
dsk.drvs=CAlloc(sizeof(CDrv)*NUM_DRVS);
for (i=0;i<NUM_DRVS;i++)
dsk.let_to_drv[i]=&dsk.drvs[i];
text.raw_col=0;
#exe {
if (kernel_cfg->opts[CFG_AUTO_MOUNT_IDE])
@@ -328,5 +329,5 @@ U0 BlkDevsInitAll()
StreamDoc(kernel_cfg->add_dev);
StreamPrint("#exe {OptOn(OPTf_WARN_PAREN);}");
};
PrtRep;
DrvRep;
}
Kernel/Dsk/Dsk1b.CPP → Kernel/Dsk/DskB.CPP
+136 -128
View File
@@ -1,9 +1,9 @@
Bool MapDrv(U8 drv_let,CPrt *p)
Bool MapDrv(U8 drv_let,CDrv *dv)
{//Make drive letter map to another.
drv_let=ToUpper(drv_let);
if ('A'<=drv_let<='Z') {
dsk.drv_to_prt[drv_let-'A']=p;
p->drv_let=drv_let;
dsk.let_to_drv[drv_let-'A']=dv;
dv->drv_let=drv_let;
return TRUE;
} else
return FALSE;
@@ -11,22 +11,22 @@ Bool MapDrv(U8 drv_let,CPrt *p)
Bool Drv(U8 drv_let)
{//Set drive. You can set drive with $LK,"Cd",A="MN:Cd"$() as well.
CPrt *p=Drv2Prt(drv_let);
CBlkDev *bdev=p->bdev;
BlkDevChk(bdev);
if (p!=Fs->cur_prt) {
if (bdev->flags & BDF_REMOVABLE && !(bdev->flags & BDF_INITIALIZED))
ChgDsk(Prt2Drv(p));
if (bdev->type==BDT_RAM)
BlkDevInit(bdev);
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
if (dv!=Fs->cur_dv) {
if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
ChgDsk(Drv2Let(dv));
if (bd->type==BDT_RAM)
BlkDevInit(bd);
}
Fs->cur_prt=p;
Fs->cur_dv=dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
switch (p->type) {
case PT_REDSEA:
case PT_FAT32:
case PT_ISO9660:
switch (dv->type) {
case DVT_REDSEA:
case DVT_FAT32:
case DVT_ISO9660:
return TRUE;
default:
PrintErr("File System Not Supported\n");
@@ -34,19 +34,21 @@ Bool Drv(U8 drv_let)
}
}
Bool Cd(U8 *dirname,Bool make_dirs=FALSE)
Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
{//Change directory. Optionally, make directories, too.
I64 maxlen,cur_dir_cluster=0;
U8 *chg_to_buf,*new_cur_dir,*buf;
CPrt *p;
CDrv *dv;
Bool result=TRUE;
if (!*dirname)
if (!dirname)
dirname="::/Home";
else if (!*dirname)
return TRUE;
if (dirname[1]==':') {
if (*dirname==':') {
if (Fs->cur_prt->drv_let!=*sys_acct && !Drv(*dirname))
if (Fs->cur_dv!=Let2Drv(':') && !Drv(*dirname))
return FALSE;
} else if (Fs->cur_prt!=Drv2Prt(*dirname) && !Drv(*dirname))
} else if (Fs->cur_dv!=Let2Drv(*dirname) && !Drv(*dirname))
return FALSE;
dirname+=2;
}
@@ -70,38 +72,31 @@ Bool Cd(U8 *dirname,Bool make_dirs=FALSE)
if (!*new_cur_dir)
StrCpy(new_cur_dir,"/");
} else if (StrCmp(buf,".") && *buf) {
if (!StrCmp(buf,"HOME")) {
result=Cd(sys_acct);
Free(new_cur_dir);
new_cur_dir=MAlloc(maxlen+StrLen(sys_acct));
StrCpy(new_cur_dir,sys_acct+2);
} else {
p=Fs->cur_prt;
cur_dir_cluster=Name2DirCluster(p,new_cur_dir);
switch (p->type) {
case PT_REDSEA:
result=RedSeaFSCd(buf,cur_dir_cluster);
break;
case PT_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case PT_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
PrintErr("File System Not Supported\n");
result=FALSE;
}
if (!result && make_dirs) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
result=MkDir(buf);
}
if (result) {
if (StrCmp(new_cur_dir,"/"))
CatPrint(new_cur_dir,"/");
CatPrint(new_cur_dir,buf);
}
dv=Fs->cur_dv;
cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
switch (dv->type) {
case DVT_REDSEA:
result=RedSeaCd(buf,cur_dir_cluster);
break;
case DVT_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case DVT_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
PrintErr("File System Not Supported\n");
result=FALSE;
}
if (!result && make_dirs) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
result=MkDir(buf);
}
if (result) {
if (StrCmp(new_cur_dir,"/"))
CatPrint(new_cur_dir,"/");
CatPrint(new_cur_dir,buf);
}
}
}
@@ -114,17 +109,17 @@ Bool Cd(U8 *dirname,Bool make_dirs=FALSE)
}
U0 FileAccessDel(CFileAccess *fa)
{//Change back to old cur_dir and prt.
CBlkDev *bdev;
{//Change back to old cur_dir and drv.
CBlkDev *bd;
if (!fa) return;
bdev=fa->old_prt->bdev;
if (!(bdev->flags & BDF_INIT_IN_PROGRESS)) {
bd=fa->old_dv->bd;
if (!(bd->flags & BDF_INIT_IN_PROGRESS)) {
if (fa->old_dir) {
Drv(Prt2Drv(fa->old_prt));
Drv(Drv2Let(fa->old_dv));
Cd(fa->old_dir);
}
} else {
Fs->cur_prt=fa->old_prt;
Fs->cur_dv=fa->old_dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
}
@@ -134,23 +129,21 @@ U0 FileAccessDel(CFileAccess *fa)
}
CFileAccess *FileAccessNew(U8 *_mask,Bool make_mask=FALSE,Bool make_dirs=FALSE,Bool no_mask=FALSE)
{//Save cur_dir and prt. Change to new dir.
{//Save cur_dir and drv. Change to new dir.
Bool valid=TRUE,old_silent;
U8 *buf,*mask,*temp_mask;
CFileAccess *fa=CAlloc(sizeof(CFileAccess));
mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_mask=mask;
fa->old_dir=StrNew(Fs->cur_dir);
fa->old_prt=Fs->cur_prt;
fa->old_dv=Fs->cur_dv;
if (*mask && mask[1]==':') {
if (Fs->cur_prt!=Drv2Prt(*mask) && !Drv(*mask))
if (Fs->cur_dv!=Let2Drv(*mask) && !Drv(*mask))
valid=FALSE;
mask+=2;
}
if (StrMatch("HOME",mask) && Fs->cur_prt!=Drv2Prt(*sys_acct))
Drv(*sys_acct);
fa->p=Fs->cur_prt;
PrtChk(fa->p);
fa->dv=Fs->cur_dv;
DrvChk(fa->dv);
buf=MAlloc(StrLen(mask)+2);
StrCpy(buf,mask);
fa->mask=MAlloc(StrLen(mask)+2);
@@ -169,7 +162,7 @@ CFileAccess *FileAccessNew(U8 *_mask,Bool make_mask=FALSE,Bool make_dirs=FALSE,B
fa->mask=StrNew("*");
} else {
if (!make_dirs || FileNameChk(fa->mask)) {
old_silent=Silent(ON);
old_silent=Silent;
//Try mask to see if Dir. If Dir, change to dir and set to "*".
if (Cd(fa->mask,make_dirs)) {
Free(fa->mask);
@@ -184,7 +177,6 @@ CFileAccess *FileAccessNew(U8 *_mask,Bool make_mask=FALSE,Bool make_dirs=FALSE,B
if (!valid) {
FileAccessDel(fa);
fa=NULL;
// throw('File');
}
return fa;
}
@@ -219,7 +211,7 @@ $LK,"DirTreeDel",A="MN:DirTreeDel"$() or $LK,"DirTreeDel2",A="MN:DirTreeDel2"$()
Bool IsDir(U8 *dir_name)
{//Is a str a valid, existing Dir?
U8 *mask=MStrPrint("%s/*",dir_name);
Bool result,old_silent=Silent(ON);
Bool result,old_silent=Silent;
CFileAccess *fa;
if (fa=FileAccessNew(mask)) {
FileAccessDel(fa);
@@ -248,14 +240,14 @@ I64 Del(U8 *files_find_mask,Bool print_msg=TRUE)
I64 result=0;
CFileAccess *fa;
if (fa=FileAccessNew(files_find_mask)) {
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSFilesDel(fa->p,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFilesDel(fa->dv,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
break;
case PT_FAT32:
result=FAT32FilesDel(fa->p,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
case DVT_FAT32:
result=FAT32FilesDel(fa->dv,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
break;
case PT_ISO9660:
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
@@ -266,7 +258,7 @@ I64 Del(U8 *files_find_mask,Bool print_msg=TRUE)
return result;
}
U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE)
U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
{//Read whole file from disk.
CHashGeneric *temph;
U8 *absname,*altname,*curname,*result=NULL;
@@ -275,8 +267,8 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE)
CArcCompress *ac;
absname=FileNameAbs(filename);
altname=ToggleZorNotZ(absname);
if (!raw && ((temph=HashFind(absname,adam_task->hash_table,HTT_FILE))||
(temph=HashFind(altname,adam_task->hash_table,HTT_FILE)))) {
if ((temph=HashFind(absname,adam_task->hash_table,HTT_FILE))||
(temph=HashFind(altname,adam_task->hash_table,HTT_FILE))) {
size=temph->user_data1;
result=MAlloc(size+1);
MemCpy(result,temph->user_data0,size);
@@ -289,15 +281,15 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE)
else
curname=altname;
if (fa=FileAccessNew(curname)) {
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSFileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case PT_FAT32:
result=FAT32FileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
case DVT_FAT32:
result=FAT32FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case PT_ISO9660:
result=ISO1FileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
case DVT_ISO9660:
result=ISO1FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
@@ -315,15 +307,15 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE)
if (fa=FileAccessNew(curname)) {
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
switch (Fs->cur_prt->type) {
case PT_REDSEA:
result=RedSeaFSFileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
switch (Fs->cur_dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case PT_FAT32:
result=FAT32FileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
case DVT_FAT32:
result=FAT32FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case PT_ISO9660:
result=ISO1FileRead(fa->p,Fs->cur_dir,fa->mask,&size,&attr);
case DVT_ISO9660:
result=ISO1FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
@@ -336,10 +328,10 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE)
"%s ",filename;
PrintErr("File not found.\n");
}
if (result && !raw && attr & RS_ATTR_RESIDENT)
if (result && attr & RS_ATTR_RESIDENT)
HashGenericAdd(curname,HTT_FILE,AMAllocIdentical(result),size,0,adam_task);
}
if (result && !raw && attr & RS_ATTR_COMPRESSED) {
if (result && attr & RS_ATTR_COMPRESSED) {
ac=result;
size=ac->expanded_size;
result=ExpandBuf(ac);
@@ -359,7 +351,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
U8 *altname,*curname,*full_name=NULL;
CDirEntry de;
CFileAccess *fa;
Bool result=FALSE;
Bool result=FALSE,old_silent;
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
if (!filename) return FALSE;
@@ -373,23 +365,31 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
curname=filename;
else
curname=altname;
if (fa=FileAccessNew(curname)) {
cur_dir_cluster=Name2DirCluster(fa->p,Fs->cur_dir);
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSFileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
old_silent=Silent;
if (!(fa=FileAccessNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case PT_FAT32:
result=FAT32FileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
case DVT_FAT32:
result=FAT32FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case PT_ISO9660:
result=ISO1FileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
case DVT_ISO9660:
result=ISO1FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
if (result && _de)
full_name=MStrPrint("%C:%s/%s",Fs->cur_prt->drv_let,Fs->cur_dir,de.name);
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",Drv2Let(Fs->cur_dv),de.name);
}
FileAccessDel(fa);
}
}
@@ -398,27 +398,35 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
curname=filename;
else
curname=altname;
if (fa=FileAccessNew(curname)) {
cur_dir_cluster=Name2DirCluster(fa->p,Fs->cur_dir);
old_silent=Silent;
if (!(fa=FileAccessNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
cur_dir_cluster=Name2DirCluster(fa->p,Fs->cur_dir);
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSFileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case PT_FAT32:
result=FAT32FileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
case DVT_FAT32:
result=FAT32FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case PT_ISO9660:
result=ISO1FileFind(fa->p,cur_dir_cluster,fa->mask,&de,fuf_flags);
case DVT_ISO9660:
result=ISO1FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
}
if (result && _de)
full_name=MStrPrint("%C:%s/%s",Fs->cur_prt->drv_let,Fs->cur_dir,de.name);
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",Drv2Let(Fs->cur_dv),de.name);
}
FileAccessDel(fa);
}
}
@@ -434,7 +442,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
}
I64 FileWrite(U8 *filename,U8 *fbuf,
I64 size,CDate cdt=0,I64 attr=0,Bool raw=FALSE)
I64 size,CDate cdt=0,I64 attr=0)
{//Write whole file to disk.
I64 c=0;
CHashGeneric *temph;
@@ -442,34 +450,34 @@ I64 FileWrite(U8 *filename,U8 *fbuf,
U8 *fbuf2,*absname=FileNameAbs(filename);
if (fa=FileAccessNew(filename,FALSE,TRUE)) {
attr=FileAttr(fa->mask,attr);
if (attr&RS_ATTR_COMPRESSED && !raw) {
if (attr&RS_ATTR_COMPRESSED) {
fbuf=CompressBuf(fbuf,size);
size=fbuf(CArcCompress *)->compressed_size;
fbuf2=fbuf;
} else
fbuf2=NULL;
if (!cdt) cdt=Now;
switch (fa->p->type) {
case PT_REDSEA:
c=RedSeaFSFileWrite(fa->p,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
switch (fa->dv->type) {
case DVT_REDSEA:
c=RedSeaFileWrite(fa->dv,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
break;
case PT_FAT32:
c=FAT32FileWrite(fa->p,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
case DVT_FAT32:
c=FAT32FileWrite(fa->dv,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
break;
case PT_ISO9660:
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
if (temph=HashFind(absname,adam_task->hash_table,HTT_FILE)) {
if (!raw && attr & RS_ATTR_RESIDENT) {
if (attr & RS_ATTR_RESIDENT) {
Free(temph->user_data0);
temph->user_data0=AMAllocIdentical(fbuf);
temph->user_data1=size;
} else
HashRemDel(temph,adam_task->hash_table);
} else if (!raw && attr & RS_ATTR_RESIDENT)
} else if (attr & RS_ATTR_RESIDENT)
HashGenericAdd(absname,HTT_FILE,AMAllocIdentical(fbuf),size,0,adam_task);
Free(fbuf2);
FileAccessDel(fa);
Kernel/Dsk/Dsk1c.CPP → Kernel/Dsk/DskC.CPP
+65 -65
View File
@@ -93,14 +93,14 @@ Bool MkDir(U8 *filename)
else {
"Make Directory:%s\n",filename;
name=MStrUtil(fa->mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSMkDir(fa->p,Fs->cur_dir,name);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaMkDir(fa->dv,Fs->cur_dir,name);
break;
case PT_FAT32:
result=FAT32MkDir(fa->p,Fs->cur_dir,name);
case DVT_FAT32:
result=FAT32MkDir(fa->dv,Fs->cur_dir,name);
break;
case PT_ISO9660:
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
@@ -119,14 +119,14 @@ I64 SysDel(U8 *wild,Bool make_mask) //this is dangerous
I64 result=0;
CFileAccess *fa;
if (fa=FileAccessNew(wild,make_mask)) {
switch (fa->p->type) {
case PT_REDSEA:
result=RedSeaFSFilesDel(fa->p,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFilesDel(fa->dv,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
break;
case PT_FAT32:
result=FAT32FilesDel(fa->p,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
case DVT_FAT32:
result=FAT32FilesDel(fa->dv,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
break;
case PT_ISO9660:
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
@@ -137,39 +137,39 @@ I64 SysDel(U8 *wild,Bool make_mask) //this is dangerous
return result;
}
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=PT_FAT32)
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
{//Format hard drive or RAM drive.
//$BK,1$Warning:$BK,0$ Destroys all previous info.
//quick=FALSE means fill entire drive
//with zeros.
//Choose $LK,"PT_FAT32",A="MN:PT_FAT32"$ or $LK,"PT_REDSEA",A="MN:PT_REDSEA"$.
//Choose $LK,"DVT_FAT32",A="MN:DVT_FAT32"$ or $LK,"DVT_REDSEA",A="MN:DVT_REDSEA"$.
//You don't format a CD-ROM with this.
CPrt *p=Drv2Prt(drv_let);
CDrv *dv=Let2Drv(drv_let);
Bool old_silent=IsSilent;
if (confirm && !AreYouSure)
return;
if (!p) {
if (!dv) {
PrintErr("Invalid Drive\n");
return;
}
switch (type) {
case PT_REDSEA:
Silent(ON);
case DVT_REDSEA:
Silent;
Drv(drv_let);
Silent(old_silent);
RedSeaFSFmt(drv_let,quick);
DskCacheInvalidate(Drv2Prt(drv_let));
RedSeaFmt(drv_let,quick);
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case PT_FAT32:
Silent(ON);
case DVT_FAT32:
Silent;
Drv(drv_let);
Silent(old_silent);
FAT32Fmt(drv_let,quick);
DskCacheInvalidate(Drv2Prt(drv_let));
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case PT_ISO9660:
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
@@ -179,34 +179,34 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=PT_FAT32)
U0 CDImageRead(U8 cd_drv_let,U8 *out_name)
{//Read entire CD/DVD image into ISO file.
CBlkDev *bdev=Drv2BlkDev(cd_drv_let);
CPrt *p=Drv2Prt(cd_drv_let);
CBlkDev *bd=Let2BlkDev(cd_drv_let);
CDrv *dv=Let2Drv(cd_drv_let);
U8 *buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS),
*out_name2=DftExt(out_name,"ISO");
CFile *f=FOpen(out_name2,"w");
I64 n,spc=bdev->blk_size>>BLK_SIZE_BITS,blk=0,cnt,retry;
BlkDevInit(bdev);
if (bdev->type!=BDT_ATAPI)
I64 n,spc=bd->blk_size>>BLK_SIZE_BITS,blk=0,cnt,retry;
BlkDevInit(bd);
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
if (!out_name)
out_name=dsk.dft_iso_filename;
cnt=CeilU64(p->size,spc);
cnt=CeilU64(dv->size,spc);
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bdev->max_reads)
n=bdev->max_reads;
if (n>bd->max_reads)
n=bd->max_reads;
retry=4;
while (--retry)
if (ATAPIReadBlks2(bdev,tS+7.0+0.004*n/spc,buf,blk/spc,n/spc,TRUE))
if (ATAPIReadBlks2(bd,tS+7.0+0.004*n/spc,buf,blk/spc,n/spc,TRUE))
//n is 0x800 if max_reads. Up to 8 additional seconds
break;
if (!retry)
ATAPIReadBlks2(bdev,0,buf,blk/spc,n/spc,TRUE);
ATAPIReadBlks2(bd,0,buf,blk/spc,n/spc,TRUE);
FWBlks(f,buf,blk,n);
cnt-=n;
@@ -222,7 +222,7 @@ class CDualBuf
U8 *buf0,*buf1;
I64 in_buf,out_buf,cnt;
U8 *filename;
CBlkDev *CD_bdev;
CBlkDev *cd_bd;
};
U0 CDImageWriteTask(CDualBuf *d)
@@ -240,8 +240,8 @@ U0 CDImageWriteTask(CDualBuf *d)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>d->CD_bdev->max_writes)
n=d->CD_bdev->max_writes;
if (n>d->cd_bd->max_writes)
n=d->cd_bd->max_writes;
if (d->in_buf&1)
buf=d->buf1;
else
@@ -261,8 +261,8 @@ U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
CDualBuf *d=CAlloc(sizeof(CDualBuf));
U8 *buf,*in_name2,*in_name3;
I64 i,n,spc,blk=0,cnt;
CPrt *p=Drv2Prt(cd_drv_let);
CBlkDev *bdev=p->bdev,*bdev2;
CDrv *dv=Let2Drv(cd_drv_let);
CBlkDev *bd=dv->bd,*bd2;
CTask *task;
Bool old_preempt;
CFile *f;
@@ -278,25 +278,25 @@ U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
}
cnt=(FSize(f)+BLK_SIZE-1)>>BLK_SIZE_BITS;
FClose(f);
if (bdev->type!=BDT_ATAPI)
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
bdev2=Drv2BlkDev(*in_name2);
while (bdev2->lock_fwding)
bdev2=bdev2->lock_fwding;
if ((bdev2->type==BDT_ATA || bdev2->type==BDT_ATAPI) &&
bdev2->base0==bdev->base0) {
bd2=Let2BlkDev(*in_name2);
while (bd2->lock_fwding)
bd2=bd2->lock_fwding; //If two blkdevs on same controller, use just one lock
if ((bd2->type==BDT_ATA || bd2->type==BDT_ATAPI) &&
bd2->base0==bd->base0) {
"Can't Burn CD on same ATA ctrller as File.\n\n";
throw('BlkDev');
}
bdev->flags|=BDF_READ_ONLY_OVERRIDE;
BlkDevInit(bdev);
spc=bdev->blk_size>>BLK_SIZE_BITS;
if (p->size<cnt)
p->size=cnt;
bd->flags|=BDF_READ_ONLY_OVERRIDE;
BlkDevInit(bd);
spc=bd->blk_size>>BLK_SIZE_BITS;
if (dv->size<cnt)
dv->size=cnt;
d->filename=in_name2;
d->CD_bdev=bdev;
d->cd_bd=bd;
d->buf0=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->buf1=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->cnt=cnt;
@@ -307,8 +307,8 @@ U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
while (d->in_buf<=d->out_buf)
Yield;
BlkDevLock(bdev);
ATAPIWaitReady(bdev,0);
BlkDevLock(bd);
ATAPIWaitReady(bd,0);
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Writing");
@@ -317,43 +317,43 @@ U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bdev->max_writes)
n=bdev->max_writes;
if (n>bd->max_writes)
n=bd->max_writes;
if (d->out_buf&1)
buf=d->buf1;
else
buf=d->buf0;
while (d->in_buf<=d->out_buf)
Yield;
ATAPIWriteBlks(bdev,buf,blk/spc,(n+spc-1)/spc);
ATAPIWriteBlks(bd,buf,blk/spc,(n+spc-1)/spc);
d->out_buf++;
cnt-=n;
blk+=n;
progress1+=n;
}
ATAPISync(bdev);
ATAPISync(bd);
progress1=0; progress1_max=2;
StrCpy(progress1_desc,"Closing");
for (i=0;i<2;i++) {
ATAPIClose(bdev,0x100,i); //Close tracks
ATAPIClose(bd,0x100,i); //Close tracks
progress1++;
}
ATAPISync(bdev);
ATAPISync(bd);
ATAPIClose(bdev,0x200); //close disk
ATAPISync(bdev);
ATAPIClose(bd,0x200); //close disk
ATAPISync(bd);
if (media_type==MT_DVD) {
ATAPIClose(bdev,0x300);
ATAPISync(bdev);
ATAPIClose(bd,0x300);
ATAPISync(bd);
}
*progress1_desc=0;
progress1=progress1_max=0;
bdev->flags&=~BDF_READ_ONLY_OVERRIDE;
BlkDevUnlock(bdev);
bd->flags&=~BDF_READ_ONLY_OVERRIDE;
BlkDevUnlock(bd);
Free(d->buf0);
Free(d->buf1);
Free(in_name2);
Kernel/Dsk/DskCFile.CPP
+39 -39
View File
@@ -22,15 +22,15 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
f->max_blk=MAX_I64;
f->file_cluster_num=INVALID_CLUSTER;
full_name=FileNameAbs(filename);
f->p=Drv2Prt(*full_name);
if (f->p->type==PT_REDSEA)
f->dv=Let2Drv(*full_name);
if (f->dv->type==DVT_REDSEA)
contiguous=TRUE;
if (contiguous) {
f->flags|=FF_CONTIGUOUS;
if (f->p->type!=PT_REDSEA && !(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
if (f->dv->type!=DVT_REDSEA && !(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
throw('File');
}
f->cluster_buf=CAlloc(f->p->spc<<BLK_SIZE_BITS);
f->cluster_buf=CAlloc(f->dv->spc<<BLK_SIZE_BITS);
if (StrOcc(flags,'w')) {
f->flags=f->flags|FF_WRITE|FF_NEEDS_WRITE;
if (StrOcc(flags,'+')) {
@@ -47,10 +47,10 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
if (fa=FileAccessNew(full_name)) {
StrCpy(f->de.name,fa->mask);
if (cnt>0) {//We pre-alloc the whole thing.
f->de.cluster=ClustersAlloc(f->p,0,
(cnt+f->p->spc-1)/f->p->spc,contiguous);
f->de.cluster=ClustersAlloc(f->dv,0,
(cnt+f->dv->spc-1)/f->dv->spc,contiguous);
f->de.size=cnt<<BLK_SIZE_BITS;
DirNew(fa->p,Fs->cur_dir,&f->de,TRUE);
DirNew(fa->dv,Fs->cur_dir,&f->de,TRUE);
f->flags&=~FF_NEW_FILE;
}
FileAccessDel(fa);
@@ -75,7 +75,7 @@ U0 FClose(CFile *f)
CFileAccess *fa;
if (f) {
if (f->flags & FF_BUF_DIRTY) {
WClusters(f->p,f->cluster_buf,f->cluster,1);
WClusters(f->dv,f->cluster_buf,f->cluster,1);
f->flags&=~FF_BUF_DIRTY;
}
if (f->flags & FF_NEEDS_WRITE) {
@@ -83,9 +83,9 @@ U0 FClose(CFile *f)
if (!(f->flags & FF_USE_OLD_DATETIME))
f->de.datetime=Now;
if (f->flags & FF_NEW_FILE)
DirNew(fa->p,Fs->cur_dir,&f->de,TRUE);
DirNew(fa->dv,Fs->cur_dir,&f->de,TRUE);
else
DirNew(fa->p,Fs->cur_dir,&f->de,FALSE);
DirNew(fa->dv,Fs->cur_dir,&f->de,FALSE);
FileAccessDel(fa);
} else
throw('File');
@@ -98,29 +98,29 @@ U0 FClose(CFile *f)
I64 FSetCluster(CFile *f,I64 c,I64 blk,Bool read)
{
CPrt *p=f->p;
CDrv *dv=f->dv;
I64 i;
if (f->cluster!=c) {
if (f->flags & FF_BUF_DIRTY) {
i=p->spc;
i=dv->spc;
if (f->max_blk!=MAX_I64) {
i=f->max_blk+1-f->file_cluster_num*p->spc;
if (i>p->spc)
i=p->spc;
i=f->max_blk+1-f->file_cluster_num*dv->spc;
if (i>dv->spc)
i=dv->spc;
}
WClustersBlks(p,f->cluster_buf,f->cluster,i);
WClustersBlks(dv,f->cluster_buf,f->cluster,i);
f->flags=f->flags & ~FF_BUF_DIRTY;
}
f->cluster=c;
f->file_cluster_num=blk/p->spc;
f->file_cluster_num=blk/dv->spc;
if (read) {
i=p->spc;
i=dv->spc;
if (f->max_blk!=MAX_I64) {
i=f->max_blk+1-f->file_cluster_num*p->spc;
if (i>p->spc)
i=p->spc;
i=f->max_blk+1-f->file_cluster_num*dv->spc;
if (i>dv->spc)
i=dv->spc;
}
c=RClustersBlks(p,f->cluster_buf,c,i);
c=RClustersBlks(dv,f->cluster_buf,c,i);
}
}
return c;
@@ -128,9 +128,9 @@ I64 FSetCluster(CFile *f,I64 c,I64 blk,Bool read)
Bool FRBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
{//Read [nth,n+cnt) blks of file.
CPrt *p=f->p;
I64 spc=p->spc,i,j,c=f->de.cluster;
if (!f || !p) return FALSE;
CDrv *dv=f->dv;
I64 spc=dv->spc,i,j,c=f->de.cluster;
if (!f || !dv) return FALSE;
if (blk==FFB_NEXT_BLK)
blk=f->fblk_num;
if (blk+cnt-1>f->max_blk)
@@ -138,7 +138,7 @@ Bool FRBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
if (cnt<=0) return TRUE;
if (f->flags & FF_CONTIGUOUS) {
RBlks(p,buf,Cluster2Blk(p,c)+blk,cnt);
RBlks(dv,buf,Cluster2Blk(dv,c)+blk,cnt);
blk+=cnt;
} else {
i=blk/spc;
@@ -147,7 +147,7 @@ Bool FRBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
i-=f->file_cluster_num;
}
if (i>0)
c=ClusterNumNext(p,c,i);
c=ClusterNumNext(dv,c,i);
if (i=blk%spc) {
c=FSetCluster(f,c,blk,TRUE);
@@ -180,9 +180,9 @@ Bool FRBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
{//Write [nth,n+cnt) blks of file.
CPrt *p=f->p;
I64 spc=p->spc,i,j,c=f->de.cluster,c1;
if (!f || !p) return FALSE;
CDrv *dv=f->dv;
I64 spc=dv->spc,i,j,c=f->de.cluster,c1;
if (!f || !dv) return FALSE;
if (blk==FFB_NEXT_BLK)
blk=f->fblk_num;
if (blk+cnt-1>f->max_blk)
@@ -191,11 +191,11 @@ Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
return FALSE;
if (cnt<=0) return TRUE;
if (f->flags & FF_CONTIGUOUS) {
WBlks(p,buf,Cluster2Blk(p,c)+blk,cnt);
WBlks(dv,buf,Cluster2Blk(dv,c)+blk,cnt);
blk+=cnt;
} else {
if (!c) {
c=ClustersAlloc(p,0,1,FALSE);
c=ClustersAlloc(dv,0,1,FALSE);
f->file_cluster_num=0;
f->cluster=c;
f->de.cluster=c;
@@ -208,11 +208,11 @@ Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
}
while (i>0) {
c1=c;
c=ClusterNumNext(p,c1,1);
c=ClusterNumNext(dv,c1,1);
if (c==INVALID_CLUSTER) {
c=ClustersAlloc(p,c1,i,FALSE);
c=ClustersAlloc(dv,c1,i,FALSE);
if (i>1)
c=ClusterNumNext(p,c,i-1);
c=ClusterNumNext(dv,c,i-1);
break;
} else
i--;
@@ -231,9 +231,9 @@ Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
blk+=j;
if (cnt>0) {
c1=c;
c=ClusterNumNext(p,c1,1);
c=ClusterNumNext(dv,c1,1);
if (c==INVALID_CLUSTER)
c=ClustersAlloc(p,c1,1,FALSE);
c=ClustersAlloc(dv,c1,1,FALSE);
}
}
while (cnt>=spc) {
@@ -245,9 +245,9 @@ Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1)
blk+=spc;
if (cnt>0) {
c1=c;
c=ClusterNumNext(p,c1,1);
c=ClusterNumNext(dv,c1,1);
if (c==INVALID_CLUSTER)
c=ClustersAlloc(p,c1,1,FALSE);
c=ClustersAlloc(dv,c1,1,FALSE);
}
}
if (cnt>0) {
Kernel/Dsk/DskCache.CPP
+12 -12
View File
@@ -23,7 +23,7 @@ U0 DskCacheInit(I64 size_in_U8s)
tempc=dsk.cache_base+i;
QueIns(tempc,dsk.cache_ctrl->last_lru);
tempc->next_hash=tempc->last_hash=tempc;
tempc->p=NULL;
tempc->dv=NULL;
tempc->blk=0;
}
@@ -60,30 +60,30 @@ U0 DskCacheQueIns(CCacheBlk *tempc)
temp_l->next_hash=temp_n->last_hash=tempc;
}
CCacheBlk *DskCacheFind(CPrt *p,I64 blk)
CCacheBlk *DskCacheFind(CDrv *dv,I64 blk)
{
CCacheBlk *tempc,*tempc1=DskCacheHash(blk);
tempc=tempc1->next_hash;
while (tempc!=tempc1) {
if (tempc->p==p && tempc->blk==blk)
if (tempc->dv==dv && tempc->blk==blk)
return tempc;
tempc=tempc->next_hash;
}
return NULL;
}
U0 DskCacheAdd(CPrt *p,U8 *buf, I64 blk, I64 cnt)
U0 DskCacheAdd(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{
CCacheBlk *tempc;
if (dsk.cache_base) {
while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
Yield;
while (cnt-->0) {
if (!(tempc=DskCacheFind(p,blk)))
if (!(tempc=DskCacheFind(dv,blk)))
tempc=dsk.cache_ctrl->next_lru;
DskCacheQueRem(tempc);
MemCpy(&tempc->body,buf,BLK_SIZE);
tempc->p=p;
tempc->dv=dv;
tempc->blk=blk;
DskCacheQueIns(tempc);
blk++;
@@ -93,7 +93,7 @@ U0 DskCacheAdd(CPrt *p,U8 *buf, I64 blk, I64 cnt)
}
}
U0 DskCacheInvalidate2(CPrt *p)
U0 DskCacheInvalidate2(CDrv *dv)
{
CCacheBlk *tempc,*tempc1;
if (dsk.cache_base) {
@@ -102,9 +102,9 @@ U0 DskCacheInvalidate2(CPrt *p)
tempc=dsk.cache_ctrl->last_lru;
while (tempc!=dsk.cache_ctrl) {
tempc1=tempc->last_lru;
if (tempc->p==p) {
if (tempc->dv==dv) {
DskCacheQueRem(tempc);
tempc->p=NULL;
tempc->dv=NULL;
tempc->blk=0;
tempc->next_hash=tempc->last_hash=tempc;
QueIns(tempc,dsk.cache_ctrl->last_lru);
@@ -115,7 +115,7 @@ U0 DskCacheInvalidate2(CPrt *p)
}
}
U0 RCache(CPrt *p,U8 **_buf, I64 *_blk, I64 *_cnt)
U0 RCache(CDrv *dv,U8 **_buf, I64 *_blk, I64 *_cnt)
{
CCacheBlk *tempc;
if (dsk.cache_base) {
@@ -123,7 +123,7 @@ U0 RCache(CPrt *p,U8 **_buf, I64 *_blk, I64 *_cnt)
Yield;
//fetch leading blks from cache
while (*_cnt>0) {
if (tempc=DskCacheFind(p,*_blk)) {
if (tempc=DskCacheFind(dv,*_blk)) {
MemCpy(*_buf,&tempc->body,BLK_SIZE);
*_cnt-=1;
*_buf+=BLK_SIZE;
@@ -133,7 +133,7 @@ U0 RCache(CPrt *p,U8 **_buf, I64 *_blk, I64 *_cnt)
}
//fetch trailing blks from cache
while (*_cnt>0) {
if (tempc=DskCacheFind(p,*_blk+*_cnt-1)) {
if (tempc=DskCacheFind(dv,*_blk+*_cnt-1)) {
MemCpy(*_buf+(*_cnt-1)<<BLK_SIZE_BITS,&tempc->body,BLK_SIZE);
*_cnt-=1;
} else
Kernel/Dsk/DskDir.CPP
+16 -17
View File
@@ -1,11 +1,11 @@
Bool DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE)
Bool DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE)
{//Makes a directory entry in the directory from a $LK,"CDirEntry",A="MN:CDirEntry"$ node.
switch (p->type) {
case PT_REDSEA:
return RedSeaFSDirNew(p,cur_dir,tempde,free_old_chain);
case PT_FAT32:
return FAT32DirNew(p,cur_dir,tempde,free_old_chain);
case PT_ISO9660:
switch (dv->type) {
case DVT_REDSEA:
return RedSeaDirNew(dv,cur_dir,tempde,free_old_chain);
case DVT_FAT32:
return FAT32DirNew(dv,cur_dir,tempde,free_old_chain);
case DVT_ISO9660:
PrintErr("Not Writable\n");
return FALSE;
default:
@@ -166,17 +166,17 @@ CDirEntry *DirFilesFlatten(CDirEntry *tempde,CDirEntry **_result,I64 fuf_flags)
CDirEntry *SysFilesFind(U8 *files_find_mask,I64 fuf_flags)
{
CPrt *p=Fs->cur_prt;
CDrv *dv=Fs->cur_dv;
CDirEntry *result=NULL;
PrtChk(p);
switch (p->type) {
case PT_REDSEA:
result=RedSeaFSFilesFind(files_find_mask,fuf_flags);
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
result=RedSeaFilesFind(files_find_mask,fuf_flags);
break;
case PT_FAT32:
case DVT_FAT32:
result=FAT32FilesFind(files_find_mask,fuf_flags);
break;
case PT_ISO9660:
case DVT_ISO9660:
result=ISO1FilesFind(files_find_mask,fuf_flags);
break;
default:
@@ -194,7 +194,7 @@ CDirEntry *SysFilesFind(U8 *files_find_mask,I64 fuf_flags)
}
U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
{//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT.Z"$ file,line link to StdOut, $LK,"DocPut",A="MN:DocPut"$.
{//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ file,line link to StdOut, $LK,"DocPut",A="MN:DocPut"$.
U8 *buf;
if (!filename) return;
if (IsRaw) {
@@ -228,7 +228,7 @@ U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
}
U0 PutDirLink(U8 *dirname)
{//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT.Z"$ dir macro to StdOut, $LK,"DocPut",A="MN:DocPut"$.
{//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ dir macro to StdOut, $LK,"DocPut",A="MN:DocPut"$.
U8 *buf;
if (!dirname) return;
if (IsRaw)
@@ -284,7 +284,6 @@ I64 Dir2(U8 *files_find_mask,I64 fuf_flags,Bool full)
PutDirLink(tempde1->name);
else
PutFileLink(tempde1->name);
'\n';
DirEntryDel(tempde1);
tempde1=tempde2;
Kernel/Dsk/DskStr.CPP
+80 -89
View File
@@ -79,170 +79,161 @@ Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
return result;
}
U0 PrtChk(CPrt *p)
{//Check for valid partition. Throw exception.
if (!p || p->pt_signature!=PRT_SIGNATURE_VAL)
throw('Prt');
U0 DrvChk(CDrv *dv)
{//Check for valid drv. Throw exception.
if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL)
throw('Drv');
}
U8 Prt2Drv(CPrt *p=NULL)
{//Prt ptr to Drv letter.
if (!p)
p=Fs->cur_prt;
PrtChk(p);
return p->drv_let;
U8 Drv2Let(CDrv *dv=NULL)
{//Drv ptr to Drv letter.
if (!dv)
dv=Fs->cur_dv;
DrvChk(dv);
return dv->drv_let;
}
CPrt *Drv2Prt(U8 drv_let=0)
{//Drv letter to Prt ptr.
CPrt *p;
CDrv *Let2Drv(U8 drv_let=0)
{//Drv letter to Drv ptr.
CDrv *dv;
if (!drv_let)
p=Fs->cur_prt;
dv=Fs->cur_dv;
else {
if (drv_let==':')
drv_let=*sys_acct;
drv_let=dsk.boot_drv_let;
drv_let=ToUpper(drv_let);
if (!('A'<=drv_let<='Z'))
throw('Prt');
p=dsk.drv_to_prt[drv_let-'A'];
throw('Drv');
dv=dsk.let_to_drv[drv_let-'A'];
}
PrtChk(p);
return p;
DrvChk(dv);
return dv;
}
U0 BlkDevChk(CBlkDev *bdev)
U0 BlkDevChk(CBlkDev *bd)
{//Check for valid BlkDev. Throw exception.
if (!bdev || bdev->bd_signature!=BD_SIGNATURE_VAL ||
!(BDT_NULL<bdev->type<BDT_NUM_TYPES))
if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
!(BDT_NULL<bd->type<BDT_NUM_TYPES))
throw('BlkDev');
}
CBlkDev *Drv2BlkDev(U8 drv_let=0)
CBlkDev *Let2BlkDev(U8 drv_let=0)
{//Drv letter to BlkDev ptr.
CPrt *p=Drv2Prt(drv_let);
CBlkDev *bdev=p->bdev;
BlkDevChk(bdev);
return bdev;
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
return bd;
}
Bool IsDrvWritable(U8 drv_let=0)
{//Is drive writable?
CBlkDev *bdev=Drv2BlkDev(drv_let);
if (bdev->flags & BDF_READ_ONLY)
CBlkDev *bd=Let2BlkDev(drv_let);
if (bd->flags & BDF_READ_ONLY)
return FALSE;
else
return TRUE;
}
U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL)
{//MAlloc copy of cur dir with partition letter.
{//MAlloc copy of cur dir with drv letter.
U8 *st;
if (!task) task=Fs;
if (!task->cur_dir)
return NULL;
st=MAlloc(StrLen(task->cur_dir)+3,mem_task);
*st=Prt2Drv;
*st=Drv2Let(task->cur_dv);
st[1]=':';
StrCpy(st+2,task->cur_dir);
return st;
}
U8 *DirNameAbs(U8 *_dirname)
{//MAlloc absolute dir string with partition letter.
{//MAlloc absolute dir string with drv letter.
I64 maxlen;
U8 drv[3],*cur_dir,*buf2,*buf3,*buf,*dirname,*temp_name;
U8 drv[3],*result,*buf,*buf2,*buf3,*buf4,*dirname,*free_dirname;
if (!Fs->cur_dir || !*Fs->cur_dir)
return StrNew(_dirname);
dirname=MStrUtil(_dirname,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_name=dirname;
*drv=Prt2Drv;
free_dirname=dirname=MStrUtil(_dirname,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
*drv=Drv2Let;
drv[1]=':';
drv[2]=0;
if (*dirname && dirname[1]==':') {
if (*dirname==':')
*drv=*sys_acct;
*drv=dsk.boot_drv_let;
else
*drv=*dirname;
dirname=dirname+2;
cur_dir=StrNew("/");
buf=StrNew("/");
} else
cur_dir=StrNew(Fs->cur_dir);
buf=StrNew(Fs->cur_dir);
if (*dirname=='/') {
Free(cur_dir);
cur_dir=StrNew("/");
Free(buf);
buf=StrNew("/");
dirname++;
}
buf2=StrNew(dirname);
maxlen=StrLen(cur_dir)+1+StrLen(buf2)+1;
maxlen=StrLen(buf)+1+StrLen(buf2)+1;
buf3=MAlloc(maxlen);
buf =MAlloc(maxlen);
StrCpy(buf3,cur_dir);
buf4=MAlloc(maxlen);
StrCpy(buf3,buf);
while (*buf2) {
StrFirstRem(buf2,"/",buf);
if (!*buf)
StrFirstRem(buf2,"/",buf4);
if (!*buf4)
StrCpy(buf3,"/");
else if (!StrCmp(buf,"..")) {
else if (!StrCmp(buf4,"..")) {
StrLastRem(buf3,"/");
if (!*buf3)
StrCpy(buf3,"/");
} else if (!StrCmp(buf,".")) {
} else if (!StrCmp(buf4,".")) {
;
} else if (*buf) {
if (!StrCmp(buf,"HOME")) {
Free(buf3);
buf3=MAlloc(maxlen+StrLen(sys_acct));
StrCpy(buf3,sys_acct+2);
*drv=*sys_acct;
} else {
if (StrCmp(buf3,"/"))
CatPrint(buf3,"/");
CatPrint(buf3,buf);
}
} else if (*buf4) {
if (StrCmp(buf3,"/"))
CatPrint(buf3,"/");
CatPrint(buf3,buf4);
}
}
Free(cur_dir);
cur_dir=MAlloc(StrLen(buf3)+3);
StrCpy(cur_dir,drv);
StrCpy(cur_dir+2,buf3);
Free(buf);
result=MAlloc(StrLen(buf3)+3);
StrCpy(result,drv);
StrCpy(result+2,buf3);
Free(buf2);
Free(buf3);
Free(temp_name);
return cur_dir;
Free(buf4);
Free(free_dirname);
return result;
}
U8 *FileNameAbs(U8 *_filename,I64 fuf_flags=0)
{//Absolute filename. Accepts $LK,"FUF_Z_OR_NOT_Z",A="MN:FUF_Z_OR_NOT_Z"$, $LK,"FUF_SCAN_PARENTS",A="MN:FUF_SCAN_PARENTS"$.
U8 *buf,*buf2,*buf3,*filename,*temp_name,*temp_buf;
U8 *result,*filename,*buf,*buf_file,*buf_dir,*free_filename,*free_buf;
CDirEntry de;
filename=MStrUtil(_filename,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_name=filename;
buf=StrNew(filename);
temp_buf=buf;
free_filename=filename=MStrUtil(_filename,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
free_buf=buf=StrNew(filename);
if (*buf && buf[1]==':') {
buf+=2;
filename+=2;
}
buf2=MAlloc(StrLen(temp_name)+1);
StrLastRem(buf,"/",buf2);
buf_file=MAlloc(StrLen(free_filename)+1);
StrLastRem(buf,"/",buf_file);
if (*filename=='/' && !*buf)
StrCpy(buf,"/");
buf3=DirNameAbs(temp_buf);
Free(temp_buf);
buf=MAlloc(StrLen(buf3)+1+StrLen(buf2)+1);
StrCpy(buf,buf3);
if (buf[StrLen(buf)-1]!='/')
CatPrint(buf,"/");
CatPrint(buf,buf2);
Free(buf2);
Free(buf3);
Free(temp_name);
if (fuf_flags&&FileFind(buf,&de,fuf_flags|FUF_JUST_FILES)) {
Free(buf);
buf=de.full_name;
buf_dir=DirNameAbs(free_buf);
Free(free_buf);
result=MAlloc(StrLen(buf_dir)+1+StrLen(buf_file)+1);
StrCpy(result,buf_dir);
if (result[StrLen(result)-1]!='/')
CatPrint(result,"/");
CatPrint(result,buf_file);
Free(buf_file);
Free(buf_dir);
Free(free_filename);
if (fuf_flags&&FileFind(result,&de,fuf_flags|FUF_JUST_FILES)) {
Free(result);
result=de.full_name;
}
return buf;
return result;
}
U8 *ChgExt(U8 *filename,U8 *extension)
@@ -311,7 +302,7 @@ U8 *DirFile(U8 *dirname,U8 *name=NULL,U8 *_extension=NULL)
{/*Strips file from dirname, scans for file upward until found or
returns default.
("/Kernel/Hash1a.CPP.Z",NULL,NULL) returns "D:/Kernel"
("/Kernel/KHashA.CPP.Z",NULL,NULL) returns "D:/Kernel"
("/Kernel",NULL,"PRJ.Z") returns "D:/Kernel/Kernel.PRJ.Z"
("/Kernel/Dsk",NULL,"PRJ.Z") returns "D:/Kernel/Kernel.PRJ.Z"
("/Apps/Psalmody","Load","CPP.Z") returns "D:/Apps/Psalmody/Load.CPP.Z"
@@ -371,5 +362,5 @@ U8 *ToggleZorNotZ(U8 *name)
U8 *FileNameTempTxt()
{//Make pretty-safe temp filename in home dir.
return MStrPrint("HOME/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
return MStrPrint("::/Home/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
}
Kernel/Dsk/FileSysFAT.CPP
+212 -212
View File
@@ -19,42 +19,42 @@ CDate Dos2CDate(U16 t,U16 d)
return Struct2Date(&ds)-local_time_offset;
}
U0 FAT32PrtInit(CPrt *p)
U0 FAT32DrvInit(CDrv *dv)
{
CFAT32Boot br32;
Bool unlock;
try {
unlock=PrtLock(p);
p->type=PT_FAT32;
RBlks(p,&br32,p->offset,1);
p->file_system_info_sect=p->offset+br32.file_system_info_sect;
p->map1=p->offset+br32.reserved_sects;
p->map2=p->map1+br32.sects_per_fat;
p->data=p->map2+br32.sects_per_fat-2*br32.sects_per_cluster; //Starts at Cluster 2
p->spc=br32.sects_per_cluster;
p->root_cluster=br32.root_cluster;
MapBufAlloc(p,1);
Free(p->fis);
p->fis=AMAlloc(BLK_SIZE);
RBlks(p,p->fis,p->file_system_info_sect,1);
unlock=DrvLock(dv);
dv->type=DVT_FAT32;
RBlks(dv,&br32,dv->base_offset,1);
dv->file_system_info_sect=dv->base_offset+br32.file_system_info_sect;
dv->map1=dv->base_offset+br32.reserved_sects;
dv->map2=dv->map1+br32.sects_per_fat;
dv->data_area=dv->map2+br32.sects_per_fat-2*br32.sects_per_cluster; //Starts at Cluster 2
dv->spc=br32.sects_per_cluster;
dv->root_cluster=br32.root_cluster;
DrvMapBlkAlloc(dv);
Free(dv->fis);
dv->fis=AMAlloc(BLK_SIZE);
RBlks(dv,dv->fis,dv->file_system_info_sect,1);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
}
Bool FAT32DrvValidate(U8 drv_let)
{
CPrt *p;
CDrv *dv;
CFAT32Boot br;
Bool result=FALSE;
try {
p=Drv2Prt(drv_let);
if (p->type==PT_FAT32 &&
RBlks(p,&br,p->offset,1) &&
dv=Let2Drv(drv_let);
if (dv->type==DVT_FAT32 &&
RBlks(dv,&br,dv->base_offset,1) &&
br.signature==0xAA55 &&
br.sects==p->size)
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
@@ -65,28 +65,28 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
{
CFAT32Boot *br=CAlloc(BLK_SIZE);
CFAT32FileInfoSect *fis=CAlloc(BLK_SIZE);
CPrt *p=Drv2Prt(drv_let);
CDrv *dv=Let2Drv(drv_let);
I64 i,l;
try {
PrtLock(p);
SetDrvType(drv_let,PT_FAT32);
p->type=PT_FAT32;
DrvLock(dv);
DrvTypeSet(drv_let,DVT_FAT32);
dv->type=DVT_FAT32;
br->jump_and_nop[0]=OC_JMP_REL8;
br->jump_and_nop[1]=offset(CFAT32Boot.code)-2;
br->jump_and_nop[2]=OC_NOP;
MemCpy(br->oem_name,"MSWIN4.1",8);
br->oem_name[0](I64)='MSWIN4.1';
br->bytes_per_sect=BLK_SIZE;
if (p->size<= 500000)
if (dv->size<= 500000)
br->sects_per_cluster=1;
else if (p->size<=2000000)
else if (dv->size<=2000000)
br->sects_per_cluster=2;
else if (p->size<=6000000)
else if (dv->size<=6000000)
br->sects_per_cluster=4;
else if (p->size<=12000000)
else if (dv->size<=12000000)
br->sects_per_cluster=8;
else if (p->size<=33000000)
else if (dv->size<=33000000)
br->sects_per_cluster=16;
else if (p->size<=67000000)
else if (dv->size<=67000000)
br->sects_per_cluster=32;
else
br->sects_per_cluster=64;
@@ -94,7 +94,7 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
br->reserved_sects=32;
br->copies_of_fat=2;
br->media_desc=0xF8;
br->sects=p->size;
br->sects=dv->size;
l=(br->sects/br->sects_per_cluster)>>(BLK_SIZE_BITS-2)+1;
br->sects_per_fat=l;
br->root_cluster=2;
@@ -103,30 +103,30 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
br->ext_signature=0x29;
br->serial_num=RandU32;
MemCpy(br->vol_name,"NO NAME ",11);
MemCpy(br->fat_name,"FAT32 ",8);
br->fat_name[0](I64)='FAT32 ';
br->signature=0xAA55;
fis->signature1=0x41615252;
fis->signature2=0x61417272;
fis->signature1='RRaA';
fis->signature2='rrAa';
fis->free_clusters=-1;
fis->most_recently_allocated=0;
fis->most_recently_alloced=0;
fis->signature3=0xAA550000;
if (quick)
i=br->reserved_sects+2*l+4*br->sects_per_cluster;
else
i=p->size;
WZeroBlks(p,p->offset,i);
i=dv->size;
WZeroBlks(dv,dv->base_offset,i);
WBlks(p,fis,p->offset+br->file_system_info_sect,1);
WBlks(p,br,p->offset,1);
FAT32PrtInit(p);
ClustersAlloc(p,0,1,FALSE); //Allocate #1
br->root_cluster=ClustersAlloc(p,0,1,FALSE);
WBlks(p,br,p->offset,1);
FAT32PrtInit(p);
PrtUnlock(p);
WBlks(dv,fis,dv->base_offset+br->file_system_info_sect,1);
WBlks(dv,br,dv->base_offset,1);
FAT32DrvInit(dv);
ClustersAlloc(dv,0,1,FALSE); //Alloc #1
br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
WBlks(dv,br,dv->base_offset,1);
FAT32DrvInit(dv);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
Free(br);
Free(fis);
}
@@ -296,7 +296,7 @@ Bool FAT32DirFill(CFAT32DirEntry *de,CDirEntry *tempde,I64 *_de_cnt=NULL)
return result;
}
Bool FAT32FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
Bool result=FALSE,unlock;
CFAT32DirEntry *buf;
@@ -307,17 +307,17 @@ Bool FAT32FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 f
throw('FUF');
MemSet(_result,0,sizeof(CDirEntry));
MemSet(&long_name,0,sizeof(CDirEntry));
PrtChk(p);
if (p->type!=PT_FAT32)
PrintErr("Not FAT32 Partition\n");
DrvChk(dv);
if (dv->type!=DVT_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (!CFileNameTo(dname,name))
PrintErr("Invalid FileName.\n");
else
try {
unlock=PrtLock(p);
buf=MAlloc(BLK_SIZE*p->spc);
entries_per_cluster=p->spc<<FAT32_ENTRIES_BITS;
RClusters(p,buf,cur_dir_cluster,1);
unlock=DrvLock(dv);
buf=MAlloc(BLK_SIZE*dv->spc);
entries_per_cluster=dv->spc<<FAT32_ENTRIES_BITS;
RClusters(dv,buf,cur_dir_cluster,1);
cur_dir_entry=0;
while (ch=*buf[cur_dir_entry].name) {
attr=buf[cur_dir_entry].attr;
@@ -331,11 +331,11 @@ Bool FAT32FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 f
else
MemSet(_result,0,sizeof(CDirEntry));
if (!(fuf_flags&FUF_JUST_DIRS && !(attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && attr & RS_ATTR_DIR) &&
FAT32CDirFill(_result,&buf[cur_dir_entry]) &&
!StrCmp(dname,_result->name)) {
result=TRUE;
goto exit_this;
!(fuf_flags&FUF_JUST_FILES && attr & RS_ATTR_DIR) &&
FAT32CDirFill(_result,&buf[cur_dir_entry]) &&
!StrCmp(dname,_result->name)) {
result=TRUE;
goto fff_done;
}
}
MemSet(&long_name,0,sizeof(CDirEntry));
@@ -343,64 +343,64 @@ Bool FAT32FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 f
} else
MemSet(&long_name,0,sizeof(CDirEntry));
if (++cur_dir_entry==entries_per_cluster) {
cur_dir_cluster=ClusterNumNext(p,cur_dir_cluster);
cur_dir_cluster=ClusterNumNext(dv,cur_dir_cluster);
if (!(0<cur_dir_cluster<0x0FFFFFF8))
break;
else {
RClusters(p,buf,cur_dir_cluster,1);
RClusters(dv,buf,cur_dir_cluster,1);
cur_dir_entry=0;
}
}
}
MemSet(_result,0,sizeof(CDirEntry));
exit_this:
fff_done:
Free(buf);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
return result;
}
U8 *FAT32FileRead(CPrt *p,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
{
U8 *buf=NULL;
CDirEntry de;
I64 c,blk_cnt,cur_dir_cluster;
PrtChk(p);
DrvChk(dv);
*_size=0;
*_attr=0;
if (p->type!=PT_FAT32)
PrintErr("Not FAT32 Partition\n");
if (dv->type!=DVT_FAT32)
PrintErr("Not FAT32 Drv\n");
else
try {
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
if (FAT32FileFind(p,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
if (FAT32FileFind(dv,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
blk_cnt=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
buf=MAlloc(blk_cnt<<BLK_SIZE_BITS+1);
c=de.cluster;
if (!(0<c<0x0FFFFFF8))
c=0x0FFFFFFF;
else
c=RClustersBlks(p,buf,c,blk_cnt);
c=RClustersBlks(dv,buf,c,blk_cnt);
buf[de.size]=0; //Terminate
*_size=de.size;
*_attr=FileAttr(de.name,de.attr);
}
PrtUnlock(p);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
return buf;
}
Bool FAT32Cd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_prt->type!=PT_FAT32)
PrintErr("Not FAT32 Partition\n");
else if (FAT32FileFind(Fs->cur_prt,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
if (Fs->cur_dv->type!=DVT_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (FAT32FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
else {
"%s ",name;
@@ -409,50 +409,50 @@ Bool FAT32Cd(U8 *name,I64 cur_dir_cluster)
return FALSE;
}
U0 FAT32FreeClusters(CPrt *p,I64 c)
U0 FAT32FreeClusters(CDrv *dv,I64 c)
{
I64 next,saved_c=c;
Bool unlock,unlock_break;
PrtChk(p);
DrvChk(dv);
if (!(0<c<0x0FFFFFF8)) return;
if (p->type!=PT_FAT32)
PrintErr("Not FAT32 Partition\n");
if (dv->type!=DVT_FAT32)
PrintErr("Not FAT32 Drv\n");
else
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
CleanMAPBuf(p);
unlock=DrvLock(dv);
DrvMapBlkClean(dv);
do {
SetFSBuf(p,c,0);
next=p->cur_map_blk[c&(BLK_SIZE/4-1)];
p->cur_map_blk[c&(BLK_SIZE/4-1)]=0;
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,c,0);
next=dv->cur_map_blk[c&(BLK_SIZE/4-1)];
dv->cur_map_blk[c&(BLK_SIZE/4-1)]=0;
LBts(&dv->map_blk_dirty,0);
c=next;
} while (0<c<0x0FFFFFF8);
CleanMAPBuf(p,0);
DrvMapBlkClean(dv,0);
c=saved_c;
do {
SetFSBuf(p,c,1);
next=p->cur_map_blk[c&(BLK_SIZE/4-1)];
p->cur_map_blk[c&(BLK_SIZE/4-1)]=0;
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,c,1);
next=dv->cur_map_blk[c&(BLK_SIZE/4-1)];
dv->cur_map_blk[c&(BLK_SIZE/4-1)]=0;
LBts(&dv->map_blk_dirty,0);
c=next;
} while (0<c<0x0FFFFFF8);
CleanMAPBuf(p,1);
DrvMapBlkClean(dv,1);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
}
I64 FAT32AllocClusters(CPrt *p,I64 c,I64 cnt)
I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt)
{
Bool wrap_around=FALSE,unlock,unlock_break;
I64 first=INVALID_CLUSTER,j,l;
@@ -460,57 +460,57 @@ I64 FAT32AllocClusters(CPrt *p,I64 c,I64 cnt)
if (cnt<=0) return 0x0FFFFFFF;
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
l=(p->size+p->offset-p->data)/p->spc-1;
j=p->fis->most_recently_allocated;
unlock=DrvLock(dv);
l=(dv->size+dv->base_offset-dv->data_area)/dv->spc-1;
j=dv->fis->most_recently_alloced;
while (cnt-->0) {
while (TRUE) {
j++;
if (j<1) j=1;
if (j>=l) {
if (wrap_around)
Dbg;
throw('Drv');
j=1;
wrap_around=TRUE;
}
SetFSBuf(p,j);
if (!p->cur_map_blk[j&(BLK_SIZE/4-1)])
DrvMapBlkSet(dv,j);
if (!dv->cur_map_blk[j&(BLK_SIZE/4-1)])
break;
}
if (!(0<first<0x0FFFFFF8))
first=j;
if (0<c<l) {
SetFSBuf(p,c);
p->cur_map_blk[c&(BLK_SIZE/4-1)]=j;
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,c);
dv->cur_map_blk[c&(BLK_SIZE/4-1)]=j;
LBts(&dv->map_blk_dirty,0);
}
c=j;
}
if (0<c<l) {
SetFSBuf(p,c);
p->cur_map_blk[c&(BLK_SIZE/4-1)]=0x0FFFFFFF;
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,c);
dv->cur_map_blk[c&(BLK_SIZE/4-1)]=0x0FFFFFFF;
LBts(&dv->map_blk_dirty,0);
}
CleanMAPBuf(p);
DrvMapBlkClean(dv);
p->fis->most_recently_allocated=j;
p->fis->free_clusters=-1;
WBlks(p,p->fis,p->file_system_info_sect,1);
dv->fis->most_recently_alloced=j;
dv->fis->free_clusters=-1;
WBlks(dv,dv->fis,dv->file_system_info_sect,1);
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
return first;
}
I64 FAT32AllocContiguousClusters(CPrt *p,I64 cnt)
I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
{
I64 i,first=1;
Bool cont,unlock,unlock_break;
@@ -518,16 +518,16 @@ I64 FAT32AllocContiguousClusters(CPrt *p,I64 cnt)
if (cnt<=0) return 0x0FFFFFFF;
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
unlock=DrvLock(dv);
while (TRUE) {
first++;
i=0;
cont=TRUE;
while (cont && i<cnt) {
if ((first+i+1)*p->spc+p->data>p->size+p->offset)
Dbg;
SetFSBuf(p,first+i);
if (p->cur_map_blk[(first+i)&(BLK_SIZE/4-1)])
if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->base_offset)
throw('Drv');
DrvMapBlkSet(dv,first+i);
if (dv->cur_map_blk[(first+i)&(BLK_SIZE/4-1)])
cont=FALSE;
else
i++;
@@ -535,44 +535,44 @@ I64 FAT32AllocContiguousClusters(CPrt *p,I64 cnt)
if (!cont)
first=first+i;
else {
CleanMAPBuf(p);
DrvMapBlkClean(dv);
for (i=0;i<cnt;i++) {
SetFSBuf(p,first+i,0);
DrvMapBlkSet(dv,first+i,0);
if (i+1==cnt)
p->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
dv->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
else
p->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
LBts(p->buffered_map_dirty_bits,0);
dv->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
LBts(&dv->map_blk_dirty,0);
}
CleanMAPBuf(p,0);
DrvMapBlkClean(dv,0);
for (i=0;i<cnt;i++) {
SetFSBuf(p,first+i,1);
DrvMapBlkSet(dv,first+i,1);
if (i+1==cnt)
p->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
dv->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
else
p->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
LBts(p->buffered_map_dirty_bits,0);
dv->cur_map_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
LBts(&dv->map_blk_dirty,0);
}
CleanMAPBuf(p,1);
DrvMapBlkClean(dv,1);
break;
}
}
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
return first;
}
Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
{
//See $LK,"::/Doc/CutCorners.TXT"$.
CFAT32DirEntry *buf,*last_buf,*temp_buf,de[3];
@@ -586,12 +586,12 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
MemSet(&long_name,0,sizeof(CDirEntry));
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
buf =MAlloc(BLK_SIZE*p->spc);
last_buf=CAlloc(BLK_SIZE*p->spc);
entries_per_cluster=p->spc<<FAT32_ENTRIES_BITS;
RClusters(p,buf,cur_dir_cluster,1);
unlock=DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf =MAlloc(BLK_SIZE*dv->spc);
last_buf=CAlloc(BLK_SIZE*dv->spc);
entries_per_cluster=dv->spc<<FAT32_ENTRIES_BITS;
RClusters(dv,buf,cur_dir_cluster,1);
cur_dir_entry=0;
while (ch=*buf[cur_dir_entry].name) {
attr=buf[cur_dir_entry].attr;
@@ -607,8 +607,8 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
}
if (ch==0xE5 && !written && avail_cnt>=de_cnt) {
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
WBlks(p,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=de_cnt-1; //gets inc'ed
written=TRUE;
@@ -620,12 +620,12 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
//Del old entry with same name
if (!StrCmp(long_name.name,tempde->name)) {
if (free_old_chain)
FAT32FreeClusters(p,buf[cur_dir_entry].cluster_lo+
FAT32FreeClusters(dv,buf[cur_dir_entry].cluster_lo+
buf[cur_dir_entry].cluster_hi<<16);
if (!written) {
MemCpy(&buf[cur_dir_entry],&de[de_cnt-1],sizeof(CFAT32DirEntry));
WBlks(p,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
written=TRUE;
} else {
@@ -635,8 +635,8 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*buf[cur_dir_entry-i++].name=0xE5;
i--;
WBlks(p,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
if (i==cur_dir_entry && 0<last_dir_cluster<0x0FFFFFF8) {
@@ -645,8 +645,8 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
last_buf[entries_per_cluster-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*last_buf[entries_per_cluster-i++].name=0xE5;
if (--i>0)
WBlks(p,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
p->data+last_dir_cluster*p->spc
WBlks(dv,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
}
@@ -659,13 +659,13 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
if (++cur_dir_entry==entries_per_cluster) {
last_dir_cluster=cur_dir_cluster;
temp_buf=buf; buf=last_buf; last_buf=temp_buf;
c=ClusterNumNext(p,cur_dir_cluster);
c=ClusterNumNext(dv,cur_dir_cluster);
if (!(0<c<0x0FFFFFF8)) {
c=ClustersAlloc(p,cur_dir_cluster,1,FALSE);
MemSet(buf,0,BLK_SIZE*p->spc);
WClusters(p,buf,c,1);
c=ClustersAlloc(dv,cur_dir_cluster,1,FALSE);
MemSet(buf,0,BLK_SIZE*dv->spc);
WClusters(dv,buf,c,1);
} else
RClusters(p,buf,c,1);
RClusters(dv,buf,c,1);
cur_dir_cluster=c;
cur_dir_entry=0;
}
@@ -675,51 +675,51 @@ Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
if (avail_cnt<de_cnt) {
for (i=0;i<avail_cnt;i++)
*buf[cur_dir_entry+i].name=0xE5;
WBlks(p,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=avail_cnt;
if (cur_dir_entry==entries_per_cluster) {
last_dir_cluster=cur_dir_cluster;
temp_buf=buf; buf=last_buf; last_buf=temp_buf;
cur_dir_cluster=ClustersAlloc(p,cur_dir_cluster,1);
cur_dir_cluster=ClustersAlloc(dv,cur_dir_cluster,1);
cur_dir_entry=0;
MemSet(buf,0,BLK_SIZE*p->spc);
WClusters(p,buf,cur_dir_cluster,1);
MemSet(buf,0,BLK_SIZE*dv->spc);
WClusters(dv,buf,cur_dir_cluster,1);
}
}
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
WBlks(p,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc+
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc+
cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=de_cnt;
if (cur_dir_entry==entries_per_cluster) {
cur_dir_cluster=ClustersAlloc(p,cur_dir_cluster,1);
MemSet(buf,0,BLK_SIZE*p->spc);
WClusters(p,buf,cur_dir_cluster,1);
cur_dir_cluster=ClustersAlloc(dv,cur_dir_cluster,1);
MemSet(buf,0,BLK_SIZE*dv->spc);
WClusters(dv,buf,cur_dir_cluster,1);
} else {
MemSet(&buf[cur_dir_entry],0,sizeof(CFAT32DirEntry));
WBlks(p,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
}
}
Free(last_buf);
Free(buf);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
return FALSE;
}
I64 FAT32FilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
I64 FAT32FilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
Bool del_dir,Bool print_msg)
{
CFAT32DirEntry *buf,*last_buf,*temp_buf;
@@ -731,12 +731,12 @@ I64 FAT32FilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
MemSet(&long_name,0,sizeof(CDirEntry));
try {
unlock_break=BreakLock;
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
buf =MAlloc(BLK_SIZE*p->spc);
last_buf=CAlloc(BLK_SIZE*p->spc);
entries_per_cluster=p->spc<<FAT32_ENTRIES_BITS;
RClusters(p,buf,cur_dir_cluster,1);
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf =MAlloc(BLK_SIZE*dv->spc);
last_buf=CAlloc(BLK_SIZE*dv->spc);
entries_per_cluster=dv->spc<<FAT32_ENTRIES_BITS;
RClusters(dv,buf,cur_dir_cluster,1);
cur_dir_entry=0;
while (ch=*buf[cur_dir_entry].name) {
attr=buf[cur_dir_entry].attr;
@@ -760,8 +760,8 @@ I64 FAT32FilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*buf[cur_dir_entry-i++].name=0xE5;
i--;
WBlks(p,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
p->data+cur_dir_cluster*p->spc
WBlks(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
if (i==cur_dir_entry && last_dir_cluster!=INVALID_CLUSTER) {
@@ -770,12 +770,12 @@ I64 FAT32FilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
last_buf[entries_per_cluster-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*last_buf[entries_per_cluster-i++].name=0xE5;
if (--i>0)
WBlks(p,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
p->data+last_dir_cluster*p->spc
WBlks(dv,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
}
FAT32FreeClusters(p,buf[cur_dir_entry].cluster_lo+
FAT32FreeClusters(dv,buf[cur_dir_entry].cluster_lo+
buf[cur_dir_entry].cluster_hi<<16);
}
}
@@ -785,26 +785,26 @@ I64 FAT32FilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
MemSet(&long_name,0,sizeof(CDirEntry));
if (++cur_dir_entry==entries_per_cluster) {
last_dir_cluster=cur_dir_cluster;
cur_dir_cluster=ClusterNumNext(p,cur_dir_cluster,1);
cur_dir_cluster=ClusterNumNext(dv,cur_dir_cluster,1);
temp_buf=buf; buf=last_buf; last_buf=temp_buf;
RClusters(p,buf,cur_dir_cluster,1);
RClusters(dv,buf,cur_dir_cluster,1);
cur_dir_entry=0;
}
}
Free(buf);
Free(last_buf);
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
return result;
}
I64 FAT32FileWrite(CPrt *p,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
I64 FAT32FileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
CDate cdt,I64 attr)
{
CDirEntry de;
@@ -812,34 +812,34 @@ I64 FAT32FileWrite(CPrt *p,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
Bool contiguous;
MemSet(&de,0,sizeof(CDirEntry));
if (size<0) size=0;
if (p->type!=PT_FAT32)
PrintErr("Not FAT32 Partition\n");
if (dv->type!=DVT_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (!CFileNameTo(de.name,name))
PrintErr("Invalid FileName.\n");
else {
FAT32FilesDel(p,cur_dir,de.name,0,FALSE,FALSE);
FAT32FilesDel(dv,cur_dir,de.name,0,FALSE,FALSE);
if (attr & RS_ATTR_CONTIGUOUS)
contiguous=TRUE;
else
contiguous=FALSE;
de.size=size;
if (blk_cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS)
c=ClustersAlloc(p,0,(blk_cnt+p->spc-1)/p->spc,contiguous);
c=ClustersAlloc(dv,0,(blk_cnt+dv->spc-1)/dv->spc,contiguous);
else
c=0x0FFFFFFF;
de.cluster=c;
de.attr=attr;
de.datetime=cdt;
if (blk_cnt)
WClustersBlks(p,buf,c,blk_cnt);
FAT32DirNew(p,cur_dir,&de,TRUE);
WClustersBlks(dv,buf,c,blk_cnt);
FAT32DirNew(dv,cur_dir,&de,TRUE);
}
return c;
}
CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL)
{
CPrt *p=Fs->cur_prt;
CDrv *dv=Fs->cur_dv;
CFAT32DirEntry *buf;
I64 attr,xsum=0,dir_size=0,sub_dir_size,
cur_dir_cluster,cur_dir_entry,entries_per_cluster;
@@ -849,12 +849,12 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
throw('FUF');
try {
MemSet(&long_name,0,sizeof(CDirEntry));
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,Fs->cur_dir);
buf=MAlloc(BLK_SIZE*p->spc);
entries_per_cluster=p->spc<<FAT32_ENTRIES_BITS;
RClusters(Fs->cur_prt,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_prt->spc*BLK_SIZE;
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
buf=MAlloc(BLK_SIZE*dv->spc);
entries_per_cluster=dv->spc<<FAT32_ENTRIES_BITS;
RClusters(Fs->cur_dv,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_dv->spc*BLK_SIZE;
cur_dir_entry=0;
while (ch=*buf[cur_dir_entry].name) {
attr=buf[cur_dir_entry].attr;
@@ -874,13 +874,13 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
tempde->next=result;
result=tempde;
tempde->full_name=DirNameAbs(tempde->name);
PrtUnlock(p);
DrvUnlock(dv);
if (Cd(tempde->name)) {
tempde->sub=FAT32FilesFind(files_find_mask,fuf_flags,tempde,&sub_dir_size);
tempde->size=sub_dir_size;
Cd("..");
}
PrtLock(p);
DrvLock(dv);
} else if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' && attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
@@ -897,29 +897,29 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
} else
MemSet(&long_name,0,sizeof(CDirEntry));
if (++cur_dir_entry==entries_per_cluster) {
cur_dir_cluster=ClusterNumNext(p,cur_dir_cluster);
cur_dir_cluster=ClusterNumNext(dv,cur_dir_cluster);
if (cur_dir_cluster==INVALID_CLUSTER)
break;
else {
RClusters(p,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_prt->spc*BLK_SIZE;
RClusters(dv,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_dv->spc*BLK_SIZE;
cur_dir_entry=0;
}
}
}
Free(buf);
PrtUnlock(p);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
if (_dir_size)
*_dir_size=dir_size;
return result;
}
Bool FAT32MkDir(CPrt *p,U8 *cur_dir,U8 *name)
Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
{
I64 size=p->spc<<BLK_SIZE_BITS,c,
cur_dir_cluster=Name2DirCluster(p,cur_dir);
I64 size=dv->spc<<BLK_SIZE_BITS,c,
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
U8 *buf=CAlloc(size);
CDirEntry d_native;
CFAT32DirEntry *dFAT=buf;
@@ -927,7 +927,7 @@ Bool FAT32MkDir(CPrt *p,U8 *cur_dir,U8 *name)
try {
unlock_break=BreakLock;
c=FileWrite(name,buf,size,0,RS_ATTR_DIR,FALSE);
c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
MemSet(&d_native,0,sizeof(CDirEntry));
d_native.attr=RS_ATTR_DIR;
*d_native.name='.';
@@ -947,7 +947,7 @@ Bool FAT32MkDir(CPrt *p,U8 *cur_dir,U8 *name)
d_native.size=0;
d_native.datetime=Now;
FAT32DirFill(dFAT,&d_native);
WClusters(p,buf,c,1);
WClusters(dv,buf,c,1);
Free(buf);
if (unlock_break)
BreakUnlock;
Kernel/Dsk/FileSysISO1.CPP → Kernel/Dsk/FileSysISO.CPP
+59 -59
View File
@@ -2,57 +2,57 @@
//ISO2 is ISO13490
//ISO3 is ISO13346
Bool ISOPrtInit(CPrt *p,I64 blk)
Bool ISODrvInit(CDrv *dv,I64 blk)
{
CBlkDev *bdev=p->bdev;
I64 spc=bdev->blk_size>>BLK_SIZE_BITS,i=blk/spc;
CISO1PriDesc *iso=MAlloc(bdev->blk_size);
CBlkDev *bd=dv->bd;
I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc;
CISO1PriDesc *iso=MAlloc(bd->blk_size);
CISO1DirEntry *de;
Bool unlock,result=FALSE;
U8 buf[8];
try {
unlock=PrtLock(p);
p->type=PT_ISO9660; //default
p->spc=spc;
p->offset=p->data=p->root_cluster=p->size=0;
unlock=DrvLock(dv);
dv->type=DVT_ISO9660; //default
dv->spc=spc;
dv->base_offset=dv->data_area=dv->root_cluster=dv->size=0;
while (TRUE) {
p->size=MaxI64(p->size,(i+1)*spc);
RBlks(p,iso,i*spc,spc);
dv->size=MaxI64(dv->size,(i+1)*spc);
RBlks(dv,iso,i*spc,spc);
buf[0](U32)=iso->id[0](U32);
buf[4](U16)=iso->id[4](U8);
switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",LMF_EXACT)) {
case 0:
p->type=PT_ISO9660;
dv->type=DVT_ISO9660;
switch (iso->type) {
case ISO1T_SUPPLEMENTARY_DESC:
p->data=0;
dv->data_area=0;
de=&iso->root_dir_record;
p->root_cluster=de->loc.little;
p->size=iso->vol_space_size.little*bdev->blk_size>>BLK_SIZE_BITS;
dv->root_cluster=de->loc.little;
dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
result=TRUE;
goto ipi_done;
case ISO1T_TERMINATOR:
throw('Prt');
throw('Drv');
}
break;
default: //Its normal for ISO13346 to read NULL blk as terminator
PrintErr("File System Not Supported\n");
throw('Prt');
throw('Drv');
}
i++;
}
ipi_done:
Free(iso);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch {
p->type=PT_ISO9660;
p->spc=spc;
p->offset=p->data=p->root_cluster=0;
dv->type=DVT_ISO9660;
dv->spc=spc;
dv->base_offset=dv->data_area=dv->root_cluster=0;
Free(iso);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
}
return result;
}
@@ -126,7 +126,7 @@ Bool ISO1CDirFill(CDirEntry *tempde,CISO1DirEntry *de)
return result;
}
Bool ISO1FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
CISO1DirEntry *isoptr,*buf;
U8 dname[CDIR_FILENAME_LEN];
@@ -134,24 +134,24 @@ Bool ISO1FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fu
I64 i;
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
PrtChk(p);
if (p->type!=PT_ISO9660)
PrintErr("Not ISO9660 Partition\n");
DrvChk(dv);
if (dv->type!=DVT_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else
try {
unlock=PrtLock(p);
isoptr=MAlloc(p->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_prt,isoptr,cur_dir_cluster,1);
unlock=DrvLock(dv);
isoptr=MAlloc(dv->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_dv,isoptr,cur_dir_cluster,1);
if (isoptr->name_len==1 && !isoptr->name) {//curdir
i=(isoptr->size.little+p->spc<<BLK_SIZE_BITS-1)/p->spc<<BLK_SIZE_BITS;
buf=MAlloc(p->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_prt,buf,cur_dir_cluster,i);
i=(isoptr->size.little+dv->spc<<BLK_SIZE_BITS-1)/dv->spc<<BLK_SIZE_BITS;
buf=MAlloc(dv->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_dv,buf,cur_dir_cluster,i);
Free(isoptr);
} else {
buf=isoptr;
i=1;
}
i*=p->spc<<BLK_SIZE_BITS;
i*=dv->spc<<BLK_SIZE_BITS;
isoptr=buf;
while (i>0) {
if (!isoptr->len) {
@@ -163,9 +163,9 @@ Bool ISO1FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fu
if (!StrCmp(name,dname)) {
result=ISO1CDirFill(_result,isoptr);
if (result &&
!(fuf_flags&FUF_JUST_DIRS && !(_result->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && _result->attr & RS_ATTR_DIR) )
goto exit_this;
!(fuf_flags&FUF_JUST_DIRS && !(_result->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && _result->attr & RS_ATTR_DIR) )
goto iff_done;
else
result=FALSE;
}
@@ -174,51 +174,51 @@ Bool ISO1FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fu
isoptr(U8 *)+=isoptr->len;
}
}
exit_this:
iff_done:
Free(buf);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
return result;
}
U8 *ISO1FileRead(CPrt *p,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
U8 *ISO1FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
{
U8 *buf=NULL;
CDirEntry de;
I64 c,blk_cnt,cur_dir_cluster;
PrtChk(p);
DrvChk(dv);
*_size=0;
*_attr=0;
if (p->type!=PT_ISO9660)
PrintErr("Not ISO9660 Partition\n");
if (dv->type!=DVT_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else
try {
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
if (ISO1FileFind(p,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
if (ISO1FileFind(dv,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
blk_cnt=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
buf=MAlloc(blk_cnt<<BLK_SIZE_BITS+1);
c=de.cluster;
c=RClustersBlks(p,buf,c,blk_cnt);
c=RClustersBlks(dv,buf,c,blk_cnt);
buf[de.size]=0; //Terminate
*_size=de.size;
*_attr=FileAttr(de.name,de.attr);
}
PrtUnlock(p);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
return buf;
}
Bool ISO1Cd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_prt->type!=PT_ISO9660)
PrintErr("Not ISO9660 Partition\n");
else if (ISO1FileFind(Fs->cur_prt,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
if (Fs->cur_dv->type!=DVT_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else if (ISO1FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
else {
"%s ",name;
@@ -229,25 +229,25 @@ Bool ISO1Cd(U8 *name,I64 cur_dir_cluster)
CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL)
{
CPrt *p=Fs->cur_prt;
CDrv *dv=Fs->cur_dv;
CISO1DirEntry *buf,*buf2,*isoptr;
I64 i,cur_dir_cluster=Name2DirCluster(p,Fs->cur_dir);
I64 i,cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
CDirEntry *result=NULL,*tempde;
if (fuf_flags&~FUG_FILES_FIND)
throw('FUF');
isoptr=MAlloc(p->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_prt,isoptr,cur_dir_cluster,1);
isoptr=MAlloc(dv->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_dv,isoptr,cur_dir_cluster,1);
if (isoptr->name_len==1 && !isoptr->name) {//curdir
i=(isoptr->size.little+p->spc<<BLK_SIZE_BITS-1)/p->spc<<BLK_SIZE_BITS;
buf=MAlloc(p->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_prt,buf,cur_dir_cluster,i);
i=(isoptr->size.little+dv->spc<<BLK_SIZE_BITS-1)/dv->spc<<BLK_SIZE_BITS;
buf=MAlloc(dv->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_dv,buf,cur_dir_cluster,i);
Free(isoptr);
} else {
buf=isoptr;
i=1;
}
buf2=buf;
i*=p->spc<<BLK_SIZE_BITS;
i*=dv->spc<<BLK_SIZE_BITS;
while (i>0) {
if (!buf->len) {
buf(U8 *)++;
Kernel/Dsk/FileSysRedSea.CPP
+175 -174
View File
@@ -1,41 +1,41 @@
// See $LK,"RedSea File System",A="FI:::/Doc/RedSea.TXT"$
U0 RedSeaFSFreeFreeLst(CPrt *p)
U0 RedSeaFreeFreeLst(CDrv *dv)
{
CFreeLst *tempf,*tempf1;
Bool unlock;
try {
unlock=PrtLock(p);
if (tempf=p->next_free) {
while (tempf!=&p->next_free) {
unlock=DrvLock(dv);
if (tempf=dv->next_free) {
while (tempf!=&dv->next_free) {
tempf1=tempf->next;
Free(tempf);
tempf=tempf1;
}
}
p->next_free=NULL;
dv->next_free=NULL;
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
}
U0 RedSeaFSFreeLstBuild(CPrt *p)
U0 RedSeaFreeLstBuild(CDrv *dv)
{
Bool unlock;
CFreeLst *tempf;
I64 i,first=0,max_cluster=p->size+p->offset-p->data;
I64 i,first=dv->data_area,max_blk=dv->size+dv->base_offset;
try {
unlock=PrtLock(p);
if (p->next_free)
RedSeaFSFreeFreeLst(p);
QueInit(&p->next_free);
while (first<max_cluster) {
unlock=DrvLock(dv);
if (dv->next_free)
RedSeaFreeFreeLst(dv);
QueInit(&dv->next_free);
while (first<max_blk) {
i=0; //count free clusters
while (first+i<max_cluster) {
SetFSBuf(p,first+i);
if (Bt(p->cur_map_blk,(first+i)&(BLK_SIZE<<3-1)))
while (first+i<max_blk) {
DrvMapBlkSet(dv,first+i);
if (Bt(dv->cur_map_blk,(first+i-dv->data_area)&(BLK_SIZE<<3-1)))
break;
else
i++;
@@ -44,72 +44,73 @@ U0 RedSeaFSFreeLstBuild(CPrt *p)
tempf=AMAlloc(sizeof(CFreeLst));
tempf->size=i;
tempf->start=first;
QueIns(tempf,p->last_free);
QueIns(tempf,dv->last_free);
}
first+=i+1;
}
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
}
U0 RedSeaFSPrtInit(CPrt *p)
U0 RedSeaDrvInit(CDrv *dv)
{
CBootStruct br;
CRedSeaBoot br;
Bool unlock;
try {
unlock=PrtLock(p);
RBlks(p,&br,p->offset,1);
unlock=DrvLock(dv);
RBlks(dv,&br,dv->base_offset,1);
if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
throw('Prt');
p->type=PT_REDSEA;
RedSeaFSFreeFreeLst(p);
p->spc=1;
p->size=br.sects;
p->data=p->offset+br.bitmap_sects;
p->root_cluster=br.root_cluster;
p->map1=p->map2=p->offset+1;
MapBufAlloc(p,1);
throw('Drv');
dv->type=DVT_REDSEA;
RedSeaFreeFreeLst(dv);
dv->spc=1;
dv->size=br.sects;
dv->data_area=dv->base_offset+br.bitmap_sects;
dv->root_cluster=br.root_cluster;
dv->map1=dv->map2=dv->base_offset+1;
DrvMapBlkAlloc(dv);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
}
Bool RedSeaFSDrvValidate(U8 drv_let)
Bool RedSeaDrvValidate(U8 drv_let)
{
CPrt *p;
CBootStruct br;
CDrv *dv;
CRedSeaBoot br;
Bool result=FALSE;
try {
p=Drv2Prt(drv_let);
if (p->type==PT_REDSEA && RBlks(p,&br,p->offset,1) &&
dv=Let2Drv(drv_let);
if (dv->type==DVT_REDSEA && RBlks(dv,&br,dv->base_offset,1) &&
br.signature==MBR_PT_REDSEA && br.signature2==0xAA55 &&
br.sects==p->size)
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
return result;
}
U0 RedSeaFSFmt(U8 drv_let,Bool quick=TRUE)
U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
{
U8 *root_dir;
CDirEntry *d_native;
CBootStruct *br=CAlloc(BLK_SIZE);
CPrt *p=Drv2Prt(drv_let);
CRedSeaBoot *br=CAlloc(BLK_SIZE);
CDrv *dv=Let2Drv(drv_let);
I64 i,n;
try {
PrtLock(p);
// SetDrvType(drv_let,PT_REDSEA);
SetDrvType(drv_let,PT_FAT32);
p->type=PT_REDSEA;
DrvLock(dv);
// DrvTypeSet(drv_let,DVT_REDSEA);
DrvTypeSet(drv_let,DVT_FAT32);
dv->type=DVT_REDSEA;
br->signature=MBR_PT_REDSEA;
br->signature2=0xAA55;
br->sects=p->size;
br->base_offset=dv->base_offset; //For CD/DVD image copy.
br->sects=dv->size;
n=(br->sects+BLK_SIZE<<3-1)/BLK_SIZE<<3;
br->bitmap_sects=n;
br->unique_id=GetTSC^Now()(U64);
@@ -118,14 +119,14 @@ U0 RedSeaFSFmt(U8 drv_let,Bool quick=TRUE)
if (quick)
i=n+1;
else
i=p->size;
WZeroBlks(p,p->offset,i);
i=dv->size;
WZeroBlks(dv,dv->base_offset,i);
WBlks(p,br,p->offset,1);
RedSeaFSPrtInit(p);
ClustersAlloc(p,0,1,FALSE); //Alloc #1
br->root_cluster=ClustersAlloc(p,0,1,FALSE);
WBlks(p,br,p->offset,1);
WBlks(dv,br,dv->base_offset,1);
RedSeaDrvInit(dv);
ClustersAlloc(dv,0,1,FALSE); //Alloc #1
br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
WBlks(dv,br,dv->base_offset,1);
root_dir=CAlloc(BLK_SIZE);
d_native=root_dir-offset(CDirEntry.start);
@@ -144,16 +145,16 @@ U0 RedSeaFSFmt(U8 drv_let,Bool quick=TRUE)
d_native->cluster=br->root_cluster;
d_native->datetime=Now;
WBlks(p,root_dir,p->data+br->root_cluster,1);
RedSeaFSPrtInit(p);
PrtUnlock(p);
WBlks(dv,root_dir,br->root_cluster,1);
RedSeaDrvInit(dv);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
Free(br);
Free(root_dir);
}
Bool RedSeaFSFileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
CDirEntry *buf,*buf2,*ptr;
U8 dname[CDIR_FILENAME_LEN];
@@ -162,22 +163,22 @@ Bool RedSeaFSFileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I6
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
MemSet(_result,0,sizeof(CDirEntry));
PrtChk(p);
if (p->type!=PT_REDSEA)
PrintErr("Not RedSea Partition\n");
DrvChk(dv);
if (dv->type!=DVT_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (!CFileNameTo(dname,name))
PrintErr("Invalid FileName.\n");
else
try {
unlock=PrtLock(p);
unlock=DrvLock(dv);
buf2=MAlloc(BLK_SIZE);
RClusters(p,buf2,cur_dir_cluster,1);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RClustersBlks(p,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
Free(buf2);
ptr=buf(U8 *)-offset(CDirEntry.start);
*ptr->name='.';
ptr->name[1]=0;
@@ -185,60 +186,60 @@ Bool RedSeaFSFileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I6
if (!(ch=*ptr->name))
break;
else if (!(ptr->attr & RS_ATTR_DELETED) &&
!(fuf_flags&FUF_JUST_DIRS && !(ptr->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && ptr->attr & RS_ATTR_DIR) &&
!StrCmp(dname,ptr->name)) {
!(fuf_flags&FUF_JUST_DIRS && !(ptr->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && ptr->attr & RS_ATTR_DIR) &&
!StrCmp(dname,ptr->name)) {
MemCpy(&_result->attr,&ptr->attr,CDIR_SIZE);
result=TRUE;
goto exit_this;
goto rsff_done;
}
ptr(U8 *)+=CDIR_SIZE;
}
exit_this:
rsff_done:
Free(buf);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
} catch
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
return result;
}
U8 *RedSeaFSFileRead(CPrt *p,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
{
U8 *buf=NULL;
CDirEntry de;
I64 c,blk_cnt,cur_dir_cluster;
PrtChk(p);
DrvChk(dv);
*_size=0;
*_attr=0;
if (p->type!=PT_REDSEA)
PrintErr("Not RedSea Partition\n");
if (dv->type!=DVT_REDSEA)
PrintErr("Not RedSea Drv\n");
else
try {
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
if (RedSeaFSFileFind(p,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
if (RedSeaFileFind(dv,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
blk_cnt=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
buf=MAlloc(blk_cnt<<BLK_SIZE_BITS+1);
c=de.cluster;
c=RClustersBlks(p,buf,c,blk_cnt);
c=RBlks(dv,buf,c,blk_cnt);
buf[de.size]=0; //Terminate
*_size=de.size;
*_attr=FileAttr(de.name,de.attr);
}
PrtUnlock(p);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
return buf;
}
Bool RedSeaFSCd(U8 *name,I64 cur_dir_cluster)
Bool RedSeaCd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_prt->type!=PT_REDSEA)
PrintErr("Not RedSea Partition\n");
else if (RedSeaFSFileFind(Fs->cur_prt,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
if (Fs->cur_dv->type!=DVT_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (RedSeaFileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
else {
"%s ",name;
@@ -247,22 +248,22 @@ Bool RedSeaFSCd(U8 *name,I64 cur_dir_cluster)
return FALSE;
}
U0 RedSeaFSFreeClusters(CPrt *p,I64 c,I64 cnt)
U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
{
CFreeLst *tempf;
Bool found=FALSE,unlock,unlock_break;
PrtChk(p);
DrvChk(dv);
if (!c) return;
if (p->type!=PT_REDSEA)
PrintErr("Not RedSea Partition\n");
if (dv->type!=DVT_REDSEA)
PrintErr("Not RedSea Drv\n");
else
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
if (!p->next_free)
RedSeaFSFreeLstBuild(p);
tempf=p->next_free;
while (!found && tempf!=&p->next_free) {
unlock=DrvLock(dv);
if (!dv->next_free)
RedSeaFreeLstBuild(dv);
tempf=dv->next_free;
while (!found && tempf!=&dv->next_free) {
if (tempf->start+tempf->size==c) {
tempf->size+=cnt;
found=TRUE;
@@ -277,42 +278,42 @@ U0 RedSeaFSFreeClusters(CPrt *p,I64 c,I64 cnt)
tempf=AMAlloc(sizeof(CFreeLst));
tempf->size=cnt;
tempf->start=c;
QueIns(tempf,p->last_free);
QueIns(tempf,dv->last_free);
}
while (cnt-->0) {
SetFSBuf(p,c);
LBtr(p->cur_map_blk,c&(BLK_SIZE<<3-1));
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,c);
LBtr(dv->cur_map_blk,(c-dv->data_area)&(BLK_SIZE<<3-1));
LBts(&dv->map_blk_dirty,0);
c++;
}
CleanMAPBuf(p);
DrvMapBlkClean(dv);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
}
I64 RedSeaFSAllocClusters(CPrt *p,I64 cnt)
I64 RedSeaAllocClusters(CDrv *dv,I64 cnt)
{
CFreeLst *tempf,*best_free=NULL;
I64 i,first,best_size=MAX_I64;
Bool unlock,unlock_break;
if (cnt<=0)
Dbg;
throw('Drv');
try {
unlock_break=BreakLock;
unlock=PrtLock(p);
if (!p->next_free)
RedSeaFSFreeLstBuild(p);
tempf=p->next_free;
while (tempf!=&p->next_free) {
unlock=DrvLock(dv);
if (!dv->next_free)
RedSeaFreeLstBuild(dv);
tempf=dv->next_free;
while (tempf!=&dv->next_free) {
if (tempf->size>=cnt && tempf->size<best_size) {
best_free=tempf;
best_size=tempf->size;
@@ -322,14 +323,14 @@ I64 RedSeaFSAllocClusters(CPrt *p,I64 cnt)
tempf=tempf->next;
}
if (!best_free)
Dbg;
throw('Drv');
first=best_free->start;
for (i=0;i<cnt;i++) {
SetFSBuf(p,first+i);
LBts(p->cur_map_blk,(first+i)&(BLK_SIZE<<3-1));
LBts(p->buffered_map_dirty_bits,0);
DrvMapBlkSet(dv,first+i);
LBts(dv->cur_map_blk,(first+i-dv->data_area)&(BLK_SIZE<<3-1));
LBts(&dv->map_blk_dirty,0);
}
CleanMAPBuf(p);
DrvMapBlkClean(dv);
if (best_free->size-=cnt)
best_free->start+=cnt;
else {
@@ -337,36 +338,36 @@ I64 RedSeaFSAllocClusters(CPrt *p,I64 cnt)
Free(best_free);
}
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
return first;
}
Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
{
CDirEntry *buf,*buf2,*ptr,de2;
CBootStruct *br;
CRedSeaBoot *br;
I64 c,ch,i=1,j=0,n=BLK_SIZE/CDIR_SIZE,dir_size,cur_dir_cluster;
Bool written=FALSE,unlock,unlock_break;
U8 *temp,*parent_dir;
try {
unlock_break=BreakLock;
de->attr|=RS_ATTR_CONTIGUOUS;
unlock=PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
unlock=DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf2=MAlloc(BLK_SIZE);
RClusters(p,buf2,cur_dir_cluster,1);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RClustersBlks(p,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
dir_size=ptr->size;
ptr=buf(U8 *)-offset(CDirEntry.start)+CDIR_SIZE;
@@ -376,26 +377,26 @@ Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
if (!written)
MemCpy(&ptr->start,&de->start,CDIR_SIZE);
if ((i+1)*CDIR_SIZE+j<<BLK_SIZE_BITS<dir_size)
WBlks(p,buf(U8 *)+j<<BLK_SIZE_BITS,p->data+cur_dir_cluster+j,1);
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
else {
buf2=CAlloc(dir_size+BLK_SIZE);
MemCpy(buf2,buf,dir_size);
RedSeaFSFreeClusters(p,cur_dir_cluster,dir_size>>BLK_SIZE_BITS);
RedSeaFreeClusters(dv,cur_dir_cluster,dir_size>>BLK_SIZE_BITS);
dir_size+=BLK_SIZE;
c=ClustersAlloc(p,0,dir_size>>BLK_SIZE_BITS,TRUE);
c=ClustersAlloc(dv,0,dir_size>>BLK_SIZE_BITS,TRUE);
Free(buf);
buf=buf2;
ptr=buf(U8 *)-offset(CDirEntry.start);
ptr->size=dir_size;
ptr->cluster=c;
WClustersBlks(p,buf,c,dir_size>>BLK_SIZE_BITS);
if (cur_dir_cluster==p->root_cluster) {
WBlks(dv,buf,c,dir_size>>BLK_SIZE_BITS);
if (cur_dir_cluster==dv->root_cluster) {
br=CAlloc(BLK_SIZE);
RBlks(p,br,p->offset,1);
RBlks(dv,br,dv->base_offset,1);
br->root_cluster=c;
WBlks(p,br,p->offset,1);
WBlks(dv,br,dv->base_offset,1);
Free(br);
p->root_cluster=c;
dv->root_cluster=c;
} else {
temp=StrNew(cur_dir);
parent_dir=StrNew(cur_dir);
@@ -404,13 +405,13 @@ Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
Free(parent_dir);
parent_dir=StrNew("/");
}
if (RedSeaFSFileFind(p,Name2DirCluster(p,parent_dir),
if (RedSeaFileFind(dv,Name2DirCluster(dv,parent_dir),
temp,&de2,FUF_JUST_DIRS)) {
de2.cluster=c;
de2.size=dir_size;
RedSeaFSDirNew(p,parent_dir,&de2,FALSE);
RedSeaDirNew(dv,parent_dir,&de2,FALSE);
} else
Dbg;
throw('Drv');
Free(temp);
Free(parent_dir);
}
@@ -419,19 +420,19 @@ Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
} else if (ptr->attr & RS_ATTR_DELETED) {
if (!written) {
MemCpy(&ptr->start,&de->start,CDIR_SIZE);
WBlks(p,buf(U8 *)+j<<BLK_SIZE_BITS,p->data+cur_dir_cluster+j,1);
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
written=TRUE;
}
} else {
if (!StrCmp(de->name,ptr->name)) {
if (free_old_chain)
RedSeaFSFreeClusters(p,ptr->cluster,
RedSeaFreeClusters(dv,ptr->cluster,
(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
if (!written)
MemCpy(&ptr->start,&de->start,CDIR_SIZE);
else
ptr->attr|=RS_ATTR_DELETED;
WBlks(p,buf(U8 *)+j<<BLK_SIZE_BITS,p->data+cur_dir_cluster+j,1);
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
break;
}
}
@@ -443,19 +444,19 @@ Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
}
Free(buf);
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
if (unlock)
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
return FALSE;
}
I64 RedSeaFSFilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
I64 RedSeaFilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
Bool del_dir,Bool print_msg)
{
CDirEntry *buf,*buf2,*ptr;
@@ -463,14 +464,14 @@ I64 RedSeaFSFilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
Bool unlock_break;
try {
unlock_break=BreakLock;
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,cur_dir);
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf2=MAlloc(BLK_SIZE);
RClusters(p,buf2,cur_dir_cluster,1);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RClustersBlks(p,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
Free(buf2);
ptr=buf(U8 *)-offset(CDirEntry.start);
@@ -486,8 +487,8 @@ I64 RedSeaFSFilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
if (print_msg)
"Del %s\n",ptr->name;
ptr->attr|=RS_ATTR_DELETED;
WBlks(p,buf(U8 *)+j<<BLK_SIZE_BITS,p->data+cur_dir_cluster+j,1);
RedSeaFSFreeClusters(p,ptr->cluster,(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
RedSeaFreeClusters(dv,ptr->cluster,(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
}
ptr(U8 *)+=CDIR_SIZE;
if (++i>=n) {
@@ -496,68 +497,68 @@ I64 RedSeaFSFilesDel(CPrt *p,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
}
}
Free(buf);
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
} catch {
PrtUnlock(p);
DrvUnlock(dv);
if (unlock_break)
BreakUnlock;
}
return result;
}
I64 RedSeaFSFileWrite(CPrt *p,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
CDate cdt,I64 attr)
{
CDirEntry de;
I64 c=0,blk_cnt;
MemSet(&de,0,sizeof(CDirEntry));
if (size<0) size=0;
if (p->type!=PT_REDSEA)
PrintErr("Not RedSea Partition\n");
if (dv->type!=DVT_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (!CFileNameTo(de.name,name))
PrintErr("Invalid FileName.\n");
else {
RedSeaFSFilesDel(p,cur_dir,de.name,0,FALSE,FALSE);
RedSeaFilesDel(dv,cur_dir,de.name,0,FALSE,FALSE);
de.size=size;
if (blk_cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS)
c=ClustersAlloc(p,0,blk_cnt,TRUE); //Always contiguous
c=ClustersAlloc(dv,0,blk_cnt,TRUE); //Always contiguous
else
c=INVALID_CLUSTER;
de.cluster=c;
de.attr=attr|RS_ATTR_CONTIGUOUS;
de.datetime=cdt;
if (blk_cnt)
WClustersBlks(p,buf,c,blk_cnt);
RedSeaFSDirNew(p,cur_dir,&de,TRUE);
WBlks(dv,buf,c,blk_cnt);
RedSeaDirNew(dv,cur_dir,&de,TRUE);
}
return c;
}
CDirEntry *RedSeaFSFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL)
CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL)
{
CPrt *p=Fs->cur_prt;
CDrv *dv=Fs->cur_dv;
CDirEntry *buf,*buf2,*ptr,*result=NULL,*tempde;
I64 ch,cur_dir_cluster;
if (fuf_flags&~FUG_FILES_FIND)
throw('FUF');
try {
PrtLock(p);
cur_dir_cluster=Name2DirCluster(p,Fs->cur_dir);
DrvLock(dv);
cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
buf2=MAlloc(BLK_SIZE);
RClusters(p,buf2,cur_dir_cluster,1);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RClustersBlks(p,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
Free(buf2);
ptr=buf(U8 *)-offset(CDirEntry.start);
*ptr->name='.';
ptr->name[1]=0;
ptr(U8 *)+=CDIR_SIZE;
ptr->cluster=Name2ParentDirCluster(p,Fs->cur_dir);
ptr->cluster=Name2ParentDirCluster(dv,Fs->cur_dir);
ptr(U8 *)-=CDIR_SIZE;
while (TRUE) {
if (!(ch=*ptr->name))
@@ -570,12 +571,12 @@ CDirEntry *RedSeaFSFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent
tempde->next=result;
result=tempde;
tempde->full_name=DirNameAbs(tempde->name);
PrtUnlock(p);
DrvUnlock(dv);
if (Cd(tempde->name)) {
tempde->sub=RedSeaFSFilesFind(files_find_mask,fuf_flags,tempde);
tempde->sub=RedSeaFilesFind(files_find_mask,fuf_flags,tempde);
Cd("..");
}
PrtLock(p);
DrvLock(dv);
} else if ((tempde->attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' && tempde->attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
@@ -588,22 +589,22 @@ CDirEntry *RedSeaFSFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent
ptr(U8 *)+=CDIR_SIZE;
}
Free(buf);
PrtUnlock(p);
DrvUnlock(dv);
} catch
PrtUnlock(p);
DrvUnlock(dv);
return result;
}
Bool RedSeaFSMkDir(CPrt *p,U8 *cur_dir,U8 *name)
Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name)
{
I64 size=BLK_SIZE,c,cur_dir_cluster=Name2DirCluster(p,cur_dir);
I64 size=BLK_SIZE,c,cur_dir_cluster=Name2DirCluster(dv,cur_dir);
U8 *buf=CAlloc(size);
CDirEntry *d_native=buf-offset(CDirEntry.start);
Bool unlock_break;
try {
unlock_break=BreakLock;
c=FileWrite(name,buf,size,0,RS_ATTR_DIR,FALSE);
c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
StrCpy(d_native->name,name);
d_native->cluster=c;
@@ -618,7 +619,7 @@ Bool RedSeaFSMkDir(CPrt *p,U8 *cur_dir,U8 *name)
d_native->cluster=cur_dir_cluster;
d_native->size=0;
d_native->datetime=Now;
WClusters(p,buf,c,1);
WBlks(dv,buf,c,1);
Free(buf);
if (unlock_break)
BreakUnlock;
Kernel/EdLite.CPP
+30 -13
View File
@@ -45,7 +45,7 @@ U0 EdLiteUpdate(CLine *root,CLine *cur_line,I64 cur_col,I64 line_start_col)
templ=templ->next;
} else {
if (!done_eof) {
"<EOF>";
'<EOF>';
done_eof=TRUE;
}
'\n';
@@ -55,13 +55,14 @@ U0 EdLiteUpdate(CLine *root,CLine *cur_line,I64 cur_col,I64 line_start_col)
RawPutChar(0x7F);
}
U0 EdLite(U8 *filename,I64 num=1)
Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
{//Light weight text editor for debugging.
U8 *src,*src2,*src3,*dst,*buf,*bin_data=NULL;
I64 i,cnt=0,ch,sc,size,bin_size=0,line_start_col=0,cur_col=0,
old_raw_flags=text.raw_flags;
CLine root,*templ,*templ1,*cur_line;
Bool old_raw=Raw(ON),
Bool result=FALSE,
old_raw=Raw(ON),
old_debug=InDbg(ON),
old_single=SingleUser(ON);
@@ -103,15 +104,20 @@ U0 EdLite(U8 *filename,I64 num=1)
MemCpy(bin_data,src,bin_size);
}
Free(buf);
result=TRUE;
}
cur_line=root.next;
if (0<--num) {
if (num<cnt)
if (--num<0)
result=FALSE;
else {
if (num<=cnt)
while (num--)
cur_line=cur_line->next;
else
else {
cur_line=&root;
result=FALSE;
}
}
do {
if (cur_line==&root)
@@ -246,7 +252,10 @@ U0 EdLite(U8 *filename,I64 num=1)
}
} while (ch!=CH_SHIFT_ESC && ch!=CH_ESC);
if (ch==CH_ESC) {
if (ch!=CH_ESC) {
if (edf_dof_flags&EDF_WAS_WRITE)
result=FALSE;
} else {
size=bin_size;
templ=root.next;
@@ -268,6 +277,9 @@ U0 EdLite(U8 *filename,I64 num=1)
MemCpy(dst,bin_data,bin_size);
FileWrite(filename,buf,size);
Free(buf);
if (edf_dof_flags&EDF_WAS_WRITE)
result=TRUE;
}
templ=root.next;
@@ -285,6 +297,7 @@ U0 EdLite(U8 *filename,I64 num=1)
SingleUser(old_single);
text.raw_flags=text.raw_flags&~RWF_SHOW_DOLLAR|old_raw_flags&RWF_SHOW_DOLLAR;
POPFD
return result;
}
U0 ToFileLine(U8 *_fl_file_line,U8 **_filename,I64 *_linenum)
@@ -300,16 +313,18 @@ U0 ToFileLine(U8 *_fl_file_line,U8 **_filename,I64 *_linenum)
*_linenum=linenum;
}
U0 EdLiteFileLine(U8 *fl_file_line)
Bool EdLiteFileLine(U8 *fl_file_line,I64 edf_dof_flags=0)
{
Bool result;
U8 *filename;
I64 linenum;
ToFileLine(fl_file_line,&filename,&linenum);
EdLite(filename,linenum);
result=EdLite(filename,linenum,edf_dof_flags);
Free(filename);
return result;
}
U0 SetFix(U8 *filename,I64 line)
U0 FixSet(U8 *filename,I64 line)
{//Compiler calls this to set file line for Fix
U8 *st=MStrPrint("FL:%s,%d",filename,line);
while (LBts(&sys_semas[SYS_SEMA_FIX],0))
@@ -319,9 +334,10 @@ U0 SetFix(U8 *filename,I64 line)
LBtr(&sys_semas[SYS_SEMA_FIX],0);
}
U0 Fix()
Bool Fix(I64 edf_dof_flags=0)
{//Jump to last err src code to fix it.
U8 *st;
Bool result=FALSE;
while (LBts(&sys_semas[SYS_SEMA_FIX],0))
Yield;
@@ -330,9 +346,10 @@ U0 Fix()
if (st) {
if (IsRaw)
EdLiteFileLine(st);
result=EdLiteFileLine(st,edf_dof_flags);
else
Ed(st);
result=Ed(st,edf_dof_flags);
}
Free(st);
return result;
}
Kernel/Except.CPP
+1 -1
View File
@@ -115,7 +115,7 @@ U0 SysThrowBreak()
else {//TODO: Might want lock
Fs->wake_jiffy=0;
TaskRstAwaitingMsg;
PrtsRelease();
DrvsRelease();
BlkDevsRelease();
FlushMsgs;
throw('Break');
Kernel/Font8x8.CPP
+1 -1
View File
@@ -1,4 +1,4 @@
//See $LK,"::/Doc/Acknowledgements.TXT"$.
//See $LK,"::/Doc/Credits.TXT"$.
U8 sys_font_8x8[256*8]= {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
Kernel/Hash1b.CPP
-488
View File
@@ -1,488 +0,0 @@
I64 HashTypeNum(CHash *temph)
{//Return bit num of hash type, limited to just types.
if (temph)
return Bsf(temph->type&HTG_TYPE_MASK);
else
return -1;
}
I64 HashVal(CHash *temph)
{//Returns most likely desired value.
nobound_switch (HashTypeNum(temph)) {
case HTt_EXPORT_SYS_SYM:
return temph(CHashExport *)->val;
case HTt_IMPORT_SYS_SYM:
return temph(CHashImport *)->module_base;
case HTt_DEFINE_STR:
case HTt_CLASS:
case HTt_INTERNAL_TYPE:
case HTt_WORD:
case HTt_DICT_WORD:
case HTt_OPCODE:
case HTt_HELP_FILE:
return temph;
case HTt_GLBL_VAR:
if (temph(CHashGlblVar *)->flags&GVF_EXTERN)
return &temph(CHashGlblVar *)->data_addr;
else
return temph(CHashGlblVar *)->data_addr;
case HTt_FUN:
if (Bt(&temph(CHashFun *)->flags,Cf_EXTERN))
return temph;
else
return temph(CHashFun *)->executable_addr;
case HTt_REG:
return temph(CHashReg *)->reg_num|temph(CHashReg *)->reg_type<<8;
case HTt_KEYWORD:
case HTt_ASM_KEYWORD:
case HTt_MODULE:
case HTt_FILE:
case HTt_FRAME_PTR:
return temph(CHashGeneric *)->user_data0;
case -1: //nobound_switch
case HTt_NUM_TYPES: //nobound_switch
default:
return 0;
}
}
CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL)
{//New hash table, power-of-two in size.
CHashTable *table;
table=CAlloc(sizeof(CHashTable),mem_task);
table->body=CAlloc(size<<3,mem_task);
table->mask=size-1;
table->next_added=table->last_added=table;
return table;
}
U0 HashDel(CHashSrcSym *temph)
{//Free a std TempleOS system hash entry.
if (!temph) return;
if (!(temph->type&HTT_DICT_WORD))
Free(temph->str);
if (temph->type & HTG_SRC_SYM) {
Free(temph->src_link);
Free(temph->index);
Free(temph->import_name);
LinkedLstDel(temph->ie_lst);
if (temph->type & (HTT_FUN | HTT_EXPORT_SYS_SYM))
Free(temph->dbg_info);
if (temph->type & (HTT_FUN | HTT_CLASS))
//Assumes code not on heap, so doesn't Free.
//$LK,"MemberLstDel",A="MN:MemberLstDel"$() is an import to the Kernel module
MemberLstDel(temph);
else if (temph->type&HTT_DEFINE_STR)
Free(temph(CHashDefineStr *)->data);
else if (temph->type & HTT_GLBL_VAR) {
if (!(temph(CHashGlblVar *)->flags&GVF_ALIAS))
Free(temph(CHashGlblVar *)->data_addr);
LinkedLstDel(temph(CHashGlblVar *)->dim.next);
if (temph(CHashGlblVar *)->fun_ptr)
HashDel(temph(CHashGlblVar *)->fun_ptr-temph(CHashGlblVar *)->fun_ptr->ptr_cnt);
}
} else if (temph->type & HTT_FILE)
Free(temph(CHashGeneric *)->user_data0);
Free(temph);
}
U0 HashTableDel(CHashTable *table)
{//Free std system hash table, calling $LK,"HashDel",A="MN:HashDel"$() on entries.
CHashSrcSym *temph,*temph1;
if (!table) return;
temph=table->next_added;
while (temph!=table) {
temph1=temph->next_added;
HashDel(temph);
temph=temph1;
}
Free(table->body);
Free(table);
}
I64 HashTablePurge(CHashTable *table)
{//Eliminate ExportSysSyms that have been usurped.
I64 result=0;
CHashSrcSym *temph,*temph1,*temph2;
if (!table) return 0;
PUSHFD
CLI //Precaution
temph=table->next_added;
while (temph!=table) {
temph1=temph->next_added; //We delete only older ones
if (temph->type&(HTT_FUN|HTT_GLBL_VAR)) {
temph2=temph->next; //Older always later in chain
while (temph2) {
if ((temph2->type&HTT_EXPORT_SYS_SYM || temph2->type&HTG_TYPE_MASK==HTT_INVALID) &&
!StrCmp(temph2->str,temph->str)) {
if (temph2->type&HTG_TYPE_MASK==HTT_INVALID)
temph2->type=HTT_KEYWORD;//Won't delete HTT_INVALID
HashRemDel(temph2,table);
result++;
break;
}
temph2=temph2->next;
}
}
temph=temph1;
}
POPFD
return result;
}
CHashGeneric *HashGenericAdd(U8 *name,I64 type,I64 u0=0,I64 u1=0,I64 u2=0,CTask *task=NULL)
{//Add any type to task hash_table, 3 user_data values.
if (!task) task=Fs;
CHashGeneric *result=CAlloc(sizeof(CHashGeneric),task);
result->type=type;
result->user_data0=u0;
result->user_data1=u1;
result->user_data2=u2;
result->str=StrNew(name,task);
HashAdd(result,task->hash_table);
return result;
}
U0 SetSrcFileInfo(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0)
{//Set $LK,"CHashSrcSym",A="MN:CHashSrcSym"$ link and help_index by cur lx pos.
CLexFile *tempf=lx->cur_lfn;
I64 line_num=tempf->line_num+line_num_offset;
if (line_num<1) line_num=1;
Free(h->src_link);
h->src_link=MStrPrint("FL:%s,%d",tempf->name,line_num);
if (Bt(&lx->opts,OPTf_KEEP_PRIVATE))
h->type|=HTF_PRIVATE;
Free(h->index);
if (lx->cur_help_index)
h->index=StrNew(lx->cur_help_index);
else
h->index=NULL;
}
CHashGeneric *HashPublic(U8 *st,I64 mask,Bool val=TRUE)
{//Mark a hash entry as public and $LK,"SetSrcFileInfo",A="MN:SetSrcFileInfo"$().
CHashGeneric *result;
if (result=HashFind(st,Fs->hash_table,mask)) {
if (val)
result->type|=HTF_PUBLIC;
else
result->type&=~HTF_PUBLIC;
if (result->type&HTG_SRC_SYM)
SetSrcFileInfo(Fs->last_lex,result);
return result;
} else
return NULL;
}
I64 HashLstAdd(U8 *lst,I64 type,CHashTable *table)
{//Add a list to a hash table.
I64 i=0;
CHashGeneric *temph;
if (lst) {
while (*lst) {
if (*lst=='@')
lst++;
else
i++;
temph=CAlloc(sizeof(CHashGeneric));
temph->user_data0=i-1;
temph->str=StrNew(lst);
temph->type=type;
HashAdd(temph,table);
while (*lst++);
}
}
return i;
}
I64 HashDefineLstAdd(U8 *name,I64 type,CHashTable *table)
{//Add define list to a hash table. See $LK,"::/Adam/DolDoc/DocInit.CPP",A="FF:::/Adam/DolDoc/DocInit.CPP,HashDefineLstAdd"$.
CHashDefineStr *temph;
if (temph=HashFind(name,Fs->hash_table,HTT_DEFINE_STR))
return HashLstAdd(temph->data,type,table);
else
return 0;
}
I64 FramePtr(U8 *name,CTask *task=NULL)
{//Find entry in task->hash_table, Return user_data.
CHashGeneric *temph;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR))
return temph->user_data0;
else
return 0;
}
CHashGeneric *FramePtrAdd(U8 *name,I64 val,CTask *task=NULL)
{//Add named value to task->hash_table.
return HashGenericAdd(name,HTT_FRAME_PTR,val,0,0,task);
}
I64 FramePtrSet(U8 *name,I64 val,CTask *task=NULL)
{//Find hash entry in task->hash_table. Change user_data0.
CHashGeneric *temph;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR))
return LXchgI64(&temph->user_data0,val);
else
return 0;
}
I64 FramePtrDel(U8 *name,CTask *task=NULL)
{//Remove entry and delete.
CHashGeneric *temph;
I64 result=0;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR)) {
result=temph->user_data0;
HashRemDel(temph,task->hash_table);
}
return result;
}
U0 LoadOneImport(U8 **_src,U8 *module_base,I64 ld_flags)
{
U8 *src=*_src,*ptr2,*st_ptr;
I64 i,etype;
CHashExport *tempex=NULL;
CHashImport *tempiss;
Bool first=TRUE;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
if (*st_ptr) {
if (!first) {
*_src=st_ptr-5;
return;
} else {
first=FALSE;
if (!(tempex=HashFind(st_ptr,Fs->hash_table,HTG_ALL-HTT_IMPORT_SYS_SYM))) {
if (!(ld_flags & LDF_SILENT))
"Unresolved Reference:%s\n",st_ptr;
tempiss=CAlloc(sizeof(CHashImport));
tempiss->str=StrNew(st_ptr);
tempiss->type=HTT_IMPORT_SYS_SYM;
tempiss->module_header_entry=st_ptr-5;
tempiss->module_base=module_base;
HashAdd(tempiss,Fs->hash_table);
}
}
}
if (tempex) {
ptr2=module_base+i;
if (tempex->type & HTT_FUN)
i=tempex(CHashFun *)->executable_addr;
else if (tempex->type & HTT_GLBL_VAR)
i=tempex(CHashGlblVar *)->data_addr;
else
i=tempex->val;
switch (etype) {
case EIT_REL_I8: *ptr2(U8 *) =i-ptr2-1; break;
case EIT_IMM_U8: *ptr2(U8 *) =i; break;
case EIT_REL_I16: *ptr2(U16 *)=i-ptr2-2; break;
case EIT_IMM_U16: *ptr2(U16 *)=i; break;
case EIT_REL_I32: *ptr2(U32 *)=i-ptr2-4; break;
case EIT_IMM_U32: *ptr2(U32 *)=i; break;
case EIT_REL_I64: *ptr2(I64 *)=i-ptr2-8; break;
case EIT_IMM_U64: *ptr2(I64 *)=i; break;
}
}
}
*_src=src-1;
}
U0 SysSymImportsResolve(U8 *st_ptr,I64 ld_flags)
{
CHashImport *tempiss;
U8 *ptr;
while (tempiss=HashSingleTableFind(st_ptr,Fs->hash_table,HTT_IMPORT_SYS_SYM)) {
ptr=tempiss->module_header_entry;
LoadOneImport(&ptr,tempiss->module_base,ld_flags);
tempiss->type=HTT_INVALID;
}
}
U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
{
U8 *ptr2,*ptr3,*st_ptr;
I64 i,j,cnt,etype;
CHashExport *tempex=NULL;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_REL32_EXPORT:
case EIT_IMM32_EXPORT:
case EIT_REL64_EXPORT:
case EIT_IMM64_EXPORT:
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
if (etype==EIT_IMM32_EXPORT||etype==EIT_IMM64_EXPORT)
tempex->val=i;
else
tempex->val=i+module_base;
HashAdd(tempex,Fs->hash_table);
SysSymImportsResolve(st_ptr,ld_flags);
break;
case EIT_REL_I0...EIT_IMM_U64:
src=st_ptr-5;
LoadOneImport(&src,module_base,ld_flags);
break;
case EIT_ABS_ADDR:
if (ld_flags & LDF_NO_ABSS)
src+=i*sizeof(U32);
else {
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(U32 *)+=module_base;
}
}
break;
sub_switch_start:
case EIT_CODE_HEAP:
ptr3=MAlloc(*src(I32 *)++,Fs->code_heap);
break;
case EIT_ZEROED_CODE_HEAP:
ptr3=CAlloc(*src(I32 *)++,Fs->code_heap);
break;
sub_switch_end:
if (*st_ptr) {
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
tempex->val=ptr3;
HashAdd(tempex,Fs->hash_table);
}
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(I32 *)+=ptr3;
}
break;
sub_switch_start:
case EIT_DATA_HEAP:
ptr3=MAlloc(*src(I64 *)++);
break;
case EIT_ZEROED_DATA_HEAP:
ptr3=CAlloc(*src(I64 *)++);
break;
sub_switch_end:
if (*st_ptr) {
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
tempex->val=ptr3;
HashAdd(tempex,Fs->hash_table);
}
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(I64 *)+=ptr3;
}
break;
}
}
}
U0 LoadPass2(U8 *src,U8 *module_base,I64)
{
U8 *st_ptr;
I64 i,etype;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_MAIN:
Call(i+module_base);
break;
case EIT_ABS_ADDR:
src+=sizeof(U32)*i;
break;
case EIT_CODE_HEAP:
case EIT_ZEROED_CODE_HEAP:
src+=4+sizeof(U32)*i;
break;
case EIT_DATA_HEAP:
case EIT_ZEROED_DATA_HEAP:
src+=8+sizeof(U32)*i;
break;
}
}
}
U8 *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR)
{//Load a .BIN file module into memory.
//bfh_addr==INVALID_PTR means don't care what load addr.
U8 *fbuf,*module_base,*absname;
I64 size,module_align;
CBinFile *bfh;
fbuf=DftExt(filename,"BIN.Z");
if (!(bfh=FileRead(fbuf,&size))) {
Free(fbuf);
return NULL;
}
//See $LK,"Patch Table Generation",A="FF:::/Compiler/CmpMain.CPP,EIT_ABS_ADDR"$
module_align=1<<bfh->module_align_bits;
if (!module_align || bfh->bin_signature!=BIN_SIGNATURE_VAL) {
Free(bfh);
Free(fbuf);
throw('BinModul');
}
if (bfh_addr==INVALID_PTR) {
if (bfh->module_org==INVALID_PTR) {
if (Fs->code_heap!=Fs->data_heap) {
if (module_align<16)
module_align=16;
bfh_addr=MAllocAligned(size,module_align,Fs->code_heap,module_align-sizeof(CBinFile));
} else if (module_align>8)
bfh_addr=MAllocAligned(size,module_align,,module_align-sizeof(CBinFile));
else {//Less than 2Gig system memory
bfh_addr=bfh;
goto lo_skip; //File is already in code heap area, don't copy.
}
} else
bfh_addr=bfh->module_org;
}
MemCpy(bfh_addr,bfh,size);
Free(bfh);
lo_skip:
module_base=bfh_addr(U8 *)+sizeof(CBinFile);
absname=FileNameAbs(fbuf);
Free(fbuf);
fbuf=StrNew(absname);
FileExtRem(fbuf);
if (fbuf[1]==':' && StrLen(fbuf)>2)
HashGenericAdd(fbuf+2,HTT_MODULE|HTF_PUBLIC,bfh_addr);
LoadPass1(bfh_addr(U8 *)+bfh_addr->patch_table_offset,module_base,ld_flags);
if (!(ld_flags&LDF_JUST_LOAD))
LoadPass2(bfh_addr(U8 *)+bfh_addr->patch_table_offset,module_base,ld_flags);
Free(absname);
Free(fbuf);
return bfh_addr;
}
U0 LoadKernel()
{
HashGenericAdd(KERNEL_MODULE_NAME,HTT_MODULE|HTF_PUBLIC,sys_boot_base-sizeof(CBinFile));
//Abs patches done here $LK,"CPatchTableAbsAddr",A="FF:D:/Kernel/KStart.CPP,CPatchTableAbsAddr"$.
LoadPass1(sys_boot_patch_table_base,sys_boot_base,LDF_NO_ABSS|LDF_SILENT);
//No main routines
// LoadPass2(sys_boot_patch_table_base,sys_boot_base,0);
}
Kernel/Ints.CPP
+8 -10
View File
@@ -84,7 +84,7 @@ SYS_IRQ_FAULT::
PUSH U64 CTask.fault_err_code[RSI]
PUSH U64 CTask.fault_num[RSI]
MOV RSI,CTask.rsi[RSI]
CALL &Fault2 //See $LK,"Fault2",A="FF:::/Kernel/Dbg1a.CPP,Fault2"$
CALL &Fault2 //See $LK,"Fault2",A="FF:::/Kernel/KDbg.CPP,Fault2"$
JMP I32 RESTORE_FS_TASK_WITH_KEY_CHECK
SYS_FAULT_ERR_CODE_BITMAP::
@@ -109,10 +109,10 @@ U8 *IntEntrySet(I64 irq,U0 (*fp_new_handler)(),I64 type=IDTET_IRQ,I64 dpl=0)
//See $LK,"::/Demo/MultiCore/Interrupts.CPP"$.
I64 fp=fp_new_handler;
U8 *result,*dst;
result=IntEntryGet(irq);
dst=dev.idt(U8 *)+irq*16;
PUSHFD
CLI
result=IntEntryGet(irq);
dst=dev.idt(U8 *)+irq*16;
*dst(U16 *)++=fp.u16[0];
*dst(U16 *)++=offset(CGDT.cs64);
*dst(U16 *)++=0x8000+type<<8+dpl<<13;
@@ -160,18 +160,16 @@ U8 *IntFaultHandlersNew()
U0 IntInit1()
{//Interrupt descriptor table part1.
I64 i,temp_ptr[2];
U32 *ptr;
I64 i;
CSysLimitBase temp_ptr;
if (!Gs->num) {//Gs cur $LK,"CCPU",A="MN:CCPU"$ struct
dev.idt=CAlloc(16*256);
for (i=0;i<256;i++)
IntEntrySet(i,&IntNop);
}
ptr=temp_ptr;
*ptr(U16 *)++=256*16-1; //Typecasting is postfix
*ptr(I64 *)++=dev.idt;
*ptr(U16 *)=0;
SetRAX(temp_ptr);
temp_ptr.limit=256*16-1;
temp_ptr.base =dev.idt;
SetRAX(&temp_ptr);
LIDT U64 [RAX]
}
Kernel/KCfg.CPP
+16 -19
View File
@@ -17,19 +17,18 @@ U8 *kernel_cfg_options="MemInit\0HeapInit\0VarInit\0"
class CKernelCfg
{
U8 *acct_name;
U8 *dsk_cache_size_exp;
CDoc *add_dev;
U8 *boot_rescue_drv_file,*boot_rescue_drv_start;
Bool opts[CFG_NUM_OPTIONS];
U8 mem_init_val,heap_init_val,var_init_val,
sys_acct_drv,auto_mount_ide_hd_let,auto_mount_ide_cd_let;
boot_drv_let,auto_mount_ide_hd_let,auto_mount_ide_cd_let;
Bool cdrom_ports_pmt;
};
CDoc *KernelCfgAddDev(CKernelCfg *c)
{
I64 ch,num_hints,first_prt_num,type,unit,cnt=0;
I64 ch,num_hints,first_drv_num,type,unit,cnt=0;
U8 blks_buf[256],addr_buf[256],base0_buf[128],base1_buf[128];
CATARep *root=NULL,*tempha;
CDoc *doc=DocNew;
@@ -38,12 +37,12 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
"\n\nIn anticipation of the drives you will\n"
"define shortly, enter the drive letter\n"
"of the drive with the account directory.\n"
"\n($$PURPLE$$<ENTER>$$FG$$ for cur drv) Acct Drv:";
"\n($$PURPLE$$<ENTER>$$FG$$ for cur drv) Home Drv:";
ch=ToUpper(GetChar);
if ('A'<=ch<='Z')
c->sys_acct_drv=ch;
c->boot_drv_let=ch;
else
c->sys_acct_drv=Fs->cur_prt->drv_let;
c->boot_drv_let=Drv2Let(Fs->cur_dv);
"\n\n$$BK,1$$$$PURPLE$$Mount drives so they will be present when "
"you boot.$$FG$$$$BK,0$$\n";
@@ -55,9 +54,9 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
first_prt_num=ToUpper(GetChar)-'A';
first_drv_num=ToUpper(GetChar)-'A';
'\n';
if (0<=first_prt_num<NUM_PRTS) {
if (0<=first_drv_num<NUM_DRVS) {
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
type=GetChar-'0';
@@ -111,30 +110,30 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
LinkedLstDel(root);
}
if (BDT_NULL<type<BDT_NUM_TYPES && 0<=unit<=1) {
DocPrint(doc,"bdev=BlkDevNextFree(%d,%d);"
"bdev->unit=%d;",first_prt_num+'A',type,unit);
DocPrint(doc,"bd=BlkDevNextFree(%d,%d);"
"bd->unit=%d;",first_drv_num+'A',type,unit);
if (type==BDT_RAM) {
if (!*addr_buf) StrCpy(addr_buf,"0");
DocPrint(doc,"bdev->RAM_dsk=%s;",addr_buf);
DocPrint(doc,"bdev->max_blk=(%s)-1;",blks_buf);
DocPrint(doc,"bd->RAM_dsk=%s;",addr_buf);
DocPrint(doc,"bd->max_blk=(%s)-1;",blks_buf);
}
make_free=FALSE;
if (type==BDT_ATA || type==BDT_ATAPI) {
if (type==BDT_ATAPI && !*base0_buf) {
c->cdrom_ports_pmt=TRUE;
DocPrint(doc,"dsk.boot_rescue_drv_pmt=GetBaseUnit(bdev);");
if (first_prt_num+'A'==c->sys_acct_drv)
DocPrint(doc,"dsk.boot_rescue_drv_pmt=GetBaseUnit(bd);");
if (first_drv_num+'A'==c->boot_drv_let)
make_free=TRUE;
} else
DocPrint(doc,"bdev->base0=%s;bdev->base1=%s;",
DocPrint(doc,"bd->base0=%s;bd->base1=%s;",
base0_buf,base1_buf);
}
DocPrint(doc,"BlkDevAdd(bdev,FALSE,%d);",make_free);
DocPrint(doc,"BlkDevAdd(bd,FALSE,%d);",make_free);
cnt++;
} else
"\n\n$$BK,1$$$$RED$$Operation Failed$$BK,0$$$$FG$$\n\n";
}
} while (!cnt || 0<=first_prt_num<NUM_PRTS);
} while (!cnt || 0<=first_drv_num<NUM_DRVS);
return doc;
}
@@ -223,7 +222,6 @@ CKernelCfg *KernelCfgNew()
CKernelCfg *c=CAlloc(sizeof(CKernelCfg));
c->add_dev=KernelCfgAddDev(c);
c->acct_name=GetStr("Start-up Acct ($$PURPLE$$<ENTER>$$FG$$ will prompt):");
c->dsk_cache_size_exp=GetStr(
"Disk Cache Size in Bytes,\n"
"gets rounded-up funny,\n"
@@ -237,7 +235,6 @@ U0 KernelCfgDel(CKernelCfg *c)
{
DocDel(c->add_dev);
Free(c->boot_rescue_drv_file);
Free(c->acct_name);
Free(c->dsk_cache_size_exp);
Free(c);
}
Kernel/DataTypes1a.CPP → Kernel/KDataTypes.CPP
View File
File renamed without changes.
Kernel/Dbg1a.CPP → Kernel/KDbg.CPP
+2 -2
View File
@@ -7,7 +7,7 @@ Bool ChkPtr(U8 *ptr)
return FALSE;
} else if (ptr<sys_boot_base)
return FALSE;
else if (ptr<VGA_GRAPHIC_MEM_BASE)
else if (ptr<VGAM_GRAPHICS)
return TRUE;
else
return FALSE;
@@ -22,7 +22,7 @@ Bool ChkCodePtr(U8 *ptr)
return FALSE;
} else if (ptr<sys_boot_base)
return FALSE;
else if (ptr<VGA_GRAPHIC_MEM_BASE)
else if (ptr<VGAM_GRAPHICS)
return TRUE;
else
return FALSE;
Kernel/Define1a.CPP → Kernel/KDefine.CPP
+1 -1
View File
@@ -110,7 +110,7 @@ U0 SysDefinesLoad()
DefineLstLoad("ST_FILE_UTIL_FLAGS","r\0d\0i\0a\0c\0R\0p\0m\0x\0s\0"
"D\0F\0T\0S\0A\0J\0G\0Z\0O\0P\0f\0l\0lb\0la\0");
DefineLstLoad("ST_BLKDEV_TYPES","NULL\0RAM\0ATA\0ATAPI\0");
DefineLstLoad("ST_PRT_TYPES","NULL\0REDSEA\0FAT32\0ISO9660\0ISO13490\0ISO13346\0NTFS\0UNKNOWN\0");
DefineLstLoad("ST_DRV_TYPES","NULL\0REDSEA\0FAT32\0ISO9660\0ISO13490\0ISO13346\0NTFS\0UNKNOWN\0");
DefineLstLoad("ST_COLORS","BLACK\0BLUE\0GREEN\0CYAN\0"
"RED\0PURPLE\0BROWN\0LTGRAY\0DKGRAY\0LTBLUE\0LTGREEN\0"
"LTCYAN\0LTRED\0LTPURPLE\0YELLOW\0WHITE\0");
Kernel/KEnd.CPP
+24 -30
View File
@@ -7,12 +7,11 @@ U0 SysGlblsInit()
CPUId(0x1,&ee);
sys_cache_line_width=ee.rbx.u8[1]*8;
sys_rnd_seed =93186752^GetTSC;
sys_focus_task=Fs;
QueInit(&sys_macro_root);
dsk.dft_iso_filename="::/Temp/CDDVD.ISO";
StrCpy(dsk.temp_filename,"HOME/Temp.TXT.Z");
StrCpy(dsk.temp_filename,"::/Home/Temp.TXT.Z");
dsk.cdrom_boot_is_good=TRUE;
#exe {
if (!kernel_cfg->auto_mount_ide_hd_let) kernel_cfg->auto_mount_ide_hd_let='C';
@@ -35,10 +34,7 @@ U0 SysGlblsInit()
KeyDevInit;
#exe {
if (*kernel_cfg->acct_name)
StreamPrint("sys_acct=StrNew(\"%C:/Accts/%s\");",kernel_cfg->sys_acct_drv,kernel_cfg->acct_name);
else
StreamPrint("sys_acct=StrNew(\"%C:/Accts\");",kernel_cfg->sys_acct_drv);
StreamPrint("dsk.boot_drv_let='%C';",kernel_cfg->boot_drv_let);
StreamPrint("#exe{OptOff(OPTf_WARN_PAREN);}");
StreamPrint("DskCacheInit(%s);",kernel_cfg->dsk_cache_size_exp);
StreamPrint("#exe{OptOn(OPTf_WARN_PAREN);}");
@@ -53,9 +49,9 @@ U0 SysGlblsInit()
ProgressBarsRst;
//$AN,"Independent Heap Ctrl Example",A="Independent Heap Ctrl Example"$
//$AN,"Independent HeapCtrl Example",A="Independent HeapCtrl Example"$
i=1; //Rqst 1 blk, we might get more.
m=MemBlksUncachedAlloc(&i,sys_code_bp);
m=Mem2MegUncachedAlloc(&i,sys_code_bp);
dev.uncached_heap=HeapCtrlBPInit(m,i*0x200000/0x200);
QueInit(&dev.pci_root);
dev.mem64_ptr=MEM_MAPPED_SPACE;
@@ -65,19 +61,19 @@ U0 SysGlblsInit()
}
U0 SysGrInit()
{//See $LK,"SYS_BIOS_GR_MODE",A="FF:D:/Kernel/KStart.CPP,SYS_BIOS_GR_MODE:2"$
{
text.font=sys_font_8x8;
if (sys_bios_gr_mode==0x12) { //if 640x480 16 color
text.cols=GR_WIDTH/FONT_WIDTH;
text.rows=GR_HEIGHT/FONT_HEIGHT;
OutU8(VGA_SC_INDEX,VGA_MAP_MASK);
OutU8(VGA_SC_DATA,0x0F);
MemSet(VGA_GRAPHIC_MEM_BASE,0,GR_WIDTH*GR_HEIGHT>>3);
text.raw_screen_image=CAlloc(GR_WIDTH*GR_HEIGHT/8);
} else {
if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode
text.cols=80;
text.rows=25;
MemSet(VGA_TEXT_MEM_BASE,0,text.rows*text.cols<<1);
MemSet(VGAM_TEXT,0,text.rows*text.cols<<1);
} else { //if 640x480 16 color
text.cols=GR_WIDTH/FONT_WIDTH;
text.rows=GR_HEIGHT/FONT_HEIGHT;
OutU8(VGAP_INDEX,VGAR_MAP_MASK);
OutU8(VGAP_DATA,0x0F);
MemSet(VGAM_GRAPHICS,0,GR_WIDTH*GR_HEIGHT>>3);
text.raw_screen_image=CAlloc(GR_WIDTH*GR_HEIGHT/8);
}
}
@@ -102,7 +98,7 @@ U0 TimersInit()
_q=HPET_GCAP_ID;
i=*_q; //i.u32[1]= period in femtoS (10e-15)
if (100000<i.u32[1]<1000000000) {
cnts.HPET_freq =1000000000000000/i.u32[1];
cnts.HPET_freq =1000000000000000/i.u32[1];
cnts.HPET_kHz_freq=1000000000000/i.u32[1];
_q=HPET_GEN_CONF;
*_q|=1; //Enable counting
@@ -134,7 +130,6 @@ U0 KernelMain()
adam_task=Fs;
HeapsInit;
LBts(&sys_run_level,RLf_FULL_HEAP);
Fs->hash_table=HashTableNew(ADAM_HASH_SIZE,Fs);
SysGlblsInit;
Mem32DevInit;
MemPagesNotPresentMark;
@@ -148,31 +143,30 @@ U0 KernelMain()
TaskDerivedValsUpdate;
SysDefinesLoad;
MPInit;
BSPInit;
IntInit1;
//Before this point use $LK,"Snd",A="MN:Snd"$() and $LK,"BusyWait",A="MN:BusyWait"$()
//to debug. After this point, use $LK,"RawPrint",A="MN:RawPrint"$()
LBts(&sys_run_level,RLf_RAW);
if (BIOSTotalMem<250*0x100000)
Dbg("Requires 256 Meg of RAM Memory");
TimersInit;
IntsInit;
if (BIOSTotalMem<ToI64(0.95*MEM_MIN_MEG*0x100000))
RawPrint(4000,"!!! Requires $TX,"512 Meg",D="DD_MEM_MIN_MEG"$ of RAM Memory !!!");
IntsInit;
"Enable IRQ's\n";
SetRFlags(SYS_NORMAL_RFLAGS);
BusyWait(2000);
IntInit2;
LBts(&sys_run_level,RLf_INTERRUPTS);
TimeStampFreqCal;
Preempt(ON);
#exe {
if (!kernel_cfg->opts[CFG_NO_MP])
StreamPrint("\"MultiCore Start\\n\\n\";"
"MPStart;"
"BSPStartMP;"
"LBts(&sys_run_level,RLf_MP);");
};
@@ -201,9 +195,9 @@ U0 KernelMain()
InDbg(OFF);
cnts.time_stamp_freq_initial=TimeStampFreqCal;
Cd("/Kernel");
Cd("/");
try
ExeFile("Adam1"); //Continues $LK,"/Kernel/Adam1.CPP",A="FL:/Kernel/Adam1.CPP,1"$
ExeFile("Adam"); //Continues $LK,"/Adam.CPP",A="FL:/Adam.CPP,1"$
catch {
Raw(ON);
PutExcept;
@@ -218,7 +212,7 @@ asm { ALIGN 16,OC_NOP
SYS_KERNEL_END::
#exe {
if (kernel_cfg->opts[CFG_BOOT_RESCUE_DRV])
StreamPrint("DU8 0x%X-(SYS_KERNEL_END-SYS_KERNEL_START1+"
StreamPrint("DU8 0x%X-(SYS_KERNEL_END-SYS_KERNEL+"
"BOOT_RAM_BASE+sizeof(CBinFile)) DUP (0);"
"BINFILE \"%s\";",kernel_cfg->boot_rescue_drv_start,kernel_cfg->boot_rescue_drv_file);
};
Kernel/KExts.CPP
+29 -29
View File
@@ -9,13 +9,12 @@ import Bool Ed(U8 *link_st,I64 edf_dof_flags=0);
import I64 ExeFile(U8 *name,Bool just_load=FALSE);
import I64 ExePrint(U8 *fmt,...);
import U0 MemberLstDel(CHashClass *tempc);
import I64 PopUp(U8 *msg,CTask *parent=NULL,CTask **_pu_task=NULL);
extern U0 AdamErr(U8 *fmt,...);
extern U0 AdamLog(U8 *fmt,...);
extern I64 BlkDevAdd(CBlkDev *bdev,Bool one_prt,Bool make_free);
extern Bool BlkDevLock(CBlkDev *bdev);
extern I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free);
extern Bool BlkDevLock(CBlkDev *bd);
extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
extern Bool BlkDevUnlock(CBlkDev *bdev,Bool rst=FALSE);
extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
extern U0 BlkDevsRelease();
extern Bool BptS(U8 *addr,CTask *task=NULL,Bool live=TRUE);
extern U8 *Caller(I64 num=1);
@@ -28,51 +27,51 @@ extern I64 DefineMatch(U8 *needle,U8 *haystack_lst_name,I64 flags=0);
extern U8 *DefineSub(I64 sub,U8 *name);
extern U8 *DftExt(U8 *name,U8 *extension);
extern Bool Drv(U8 drv_let);
extern U0 DskCacheInvalidate(CPrt *p);
extern U8 Drv2Let(CDrv *dv=NULL);
extern U0 DrvsRelease();
extern U0 DskCacheInvalidate(CDrv *dv);
extern U0 Exit();
extern I64 FAT32AllocClusters(CPrt *p,I64 c,I64 cnt);
extern I64 FAT32AllocContiguousClusters(CPrt *p,I64 cnt);
extern Bool FAT32DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern Bool FAT32FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt);
extern I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt);
extern Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern U0 FAT32DrvInit(CDrv *dv);
extern Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL);
extern U0 FAT32PrtInit(CPrt *p);
extern U8 *FileExtRem(U8 *src,U8 *dst=NULL);
extern Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0);
extern U8 *FileNameAbs(U8 *name,I64 fuf_flags=0);
extern U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE);
extern I64 FileWrite(U8 *filename,U8 *fbuf,
I64 size,CDate cdt=0,I64 attr=0,Bool raw=FALSE);
extern U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL);
extern I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0);
extern I64 FlushMsgs(CTask *task=NULL);
extern I64 GetChar(I64 *scan_code=NULL,Bool echo=TRUE,Bool raw_cursor=FALSE);
extern I64 GetS(U8 *buf,I64 size,Bool allow_ext=TRUE);
extern Bool ISO1FileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL);
extern Bool ISOPrtInit(CPrt *p,I64 blk);
extern Bool ISODrvInit(CDrv *dv,I64 blk);
extern Bool IsDbg();
extern Bool IsDir(U8 *dir_name);
extern Bool IsRaw();
extern U0 MPInt(I64 num,I64 cpu_num=1);
extern U8 *MStrPrint(U8 *fmt,...);
extern Bool MkDir(U8 *filename);
extern U0 MouseIPSet(I64 x,I64 y,I64 z,I64 l,I64 r);
extern U0 Msg(I64 code,I64 a1,I64 a2,I64 flags=0);
extern I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL);
extern U0 Print(U8 *fmt,...);
extern U0 PrtsRelease();
extern U0 PutChars(U64 ch);
extern U0 PutS(U8 *st); //Use $LK,"Print",A="MN:Print"$()
extern Bool RBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt);
extern I64 RedSeaFSAllocClusters(CPrt *p,I64 cnt);
extern Bool RedSeaFSDirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern Bool RedSeaFSDrvValidate(U8 drv_let);
extern Bool RedSeaFSFileFind(CPrt *p,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *RedSeaFSFilesFind (U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL);
extern U0 RedSeaFSFmt(U8 drv_let,Bool quick=TRUE);
extern U0 RedSeaFSFreeFreeLst(CPrt *p);
extern U0 RedSeaFSPrtInit(CPrt *p);
extern U0 SetMouseIP(I64 x,I64 y,I64 z,I64 l,I64 r);
extern Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
extern I64 RedSeaAllocClusters(CDrv *dv,I64 cnt);
extern Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern U0 RedSeaDrvInit(CDrv *dv);
extern Bool RedSeaDrvValidate(U8 drv_let);
extern Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *RedSeaFilesFind (U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL);
extern U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE);
extern U0 RedSeaFreeFreeLst(CDrv *dv);
extern CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
U8 *task_name=NULL,I64 target_cpu,CTask *parent=NULL, //NULL means adam
I64 stk_size=0,I64 flags=1<<SVCf_ADD_TO_QUE);
extern CTask *SpawnUser(U8 *fmt=NULL,...);
extern U0 SrvCmdDel(CSrvCmd *tempc);
extern U0 SrvCmdQueDel(CSrvCmd *root);
extern I64 SrvCmdsHandler(CTask *task=NULL);
@@ -84,15 +83,16 @@ extern CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 code,I64 a1,I64 a2,I64 fla
extern U0 TaskRstAwaitingMsg(CTask *task=NULL);
extern Bool TaskValidate(CTask *task);
extern U0 TaskWait(CTask *task=NULL);
extern CTask *User(U8 *fmt=NULL,...);
extern U0 UserTaskCont();
extern Bool WBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt);
extern Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
extern U0 XTalk(CTask *task,U8 *fmt,...);
extern U0 throw(I64 ch=0,Bool no_log=FALSE);
#exe {
OptOn(OPTf_KEEP_PRIVATE);
OptOn(OPTf_EXTERNS_TO_IMPORTS);
};
#include "/Compiler/Cmp.HPP"
#include "/Compiler/CompilerB.HPP"
#exe {
OptOff(OPTf_EXTERNS_TO_IMPORTS);
OptOff(OPTf_KEEP_PRIVATE);
Kernel/KGlbls.CPP
-2
View File
@@ -8,8 +8,6 @@ CTask *adam_task;
I64 sys_num_spawned_tasks;
CTask *sys_winmgr_task,*sys_task_being_screen_updated;
I64 sys_rnd_seed;
U8 *sys_acct; // "D:/Acct/User"
U8 *reverse_bits_table, //Table with U8 bits reversed
*set_bits_table; //Table with count of set bits in a U8
CDate local_time_offset=0;
Kernel/Hash1a.CPP → Kernel/KHashA.CPP
BIN
View File
Binary file not shown.
Kernel/KHashB.CPP
+247
View File
@@ -0,0 +1,247 @@
I64 HashTypeNum(CHash *temph)
{//Return bit num of hash type, limited to just types.
if (temph)
return Bsf(temph->type&HTG_TYPE_MASK);
else
return -1;
}
I64 HashVal(CHash *temph)
{//Returns most likely desired value.
nobound_switch (HashTypeNum(temph)) {
case HTt_EXPORT_SYS_SYM:
return temph(CHashExport *)->val;
case HTt_IMPORT_SYS_SYM:
return temph(CHashImport *)->module_base;
case HTt_DEFINE_STR:
case HTt_CLASS:
case HTt_INTERNAL_TYPE:
case HTt_WORD:
case HTt_DICT_WORD:
case HTt_OPCODE:
case HTt_HELP_FILE:
return temph;
case HTt_GLBL_VAR:
if (temph(CHashGlblVar *)->flags&GVF_EXTERN)
return &temph(CHashGlblVar *)->data_addr;
else
return temph(CHashGlblVar *)->data_addr;
case HTt_FUN:
if (Bt(&temph(CHashFun *)->flags,Cf_EXTERN))
return temph;
else
return temph(CHashFun *)->executable_addr;
case HTt_REG:
return temph(CHashReg *)->reg_num|temph(CHashReg *)->reg_type<<8;
case HTt_KEYWORD:
case HTt_ASM_KEYWORD:
case HTt_MODULE:
case HTt_FILE:
case HTt_FRAME_PTR:
return temph(CHashGeneric *)->user_data0;
case -1: //nobound_switch
case HTt_NUM_TYPES: //nobound_switch
default:
return 0;
}
}
CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL)
{//New hash table, power-of-two in size.
CHashTable *table;
table=CAlloc(sizeof(CHashTable),mem_task);
table->body=CAlloc(size<<3,mem_task);
table->mask=size-1;
return table;
}
U0 HashDel(CHashSrcSym *temph)
{//Free a std TempleOS system hash entry.
if (!temph) return;
if (!(temph->type&HTT_DICT_WORD))
Free(temph->str);
if (temph->type & HTG_SRC_SYM) {
Free(temph->src_link);
Free(temph->index);
Free(temph->import_name);
LinkedLstDel(temph->ie_lst);
if (temph->type & (HTT_FUN | HTT_EXPORT_SYS_SYM))
Free(temph->dbg_info);
if (temph->type & (HTT_FUN | HTT_CLASS))
//Assumes code not on heap, so doesn't Free.
//$LK,"MemberLstDel",A="MN:MemberLstDel"$() is an import to the Kernel module
MemberLstDel(temph);
else if (temph->type&HTT_DEFINE_STR)
Free(temph(CHashDefineStr *)->data);
else if (temph->type & HTT_GLBL_VAR) {
if (!(temph(CHashGlblVar *)->flags&GVF_ALIAS))
Free(temph(CHashGlblVar *)->data_addr);
LinkedLstDel(temph(CHashGlblVar *)->dim.next);
if (temph(CHashGlblVar *)->fun_ptr)
HashDel(temph(CHashGlblVar *)->fun_ptr-temph(CHashGlblVar *)->fun_ptr->ptr_stars_cnt);
}
} else if (temph->type & HTT_FILE)
Free(temph(CHashGeneric *)->user_data0);
Free(temph);
}
U0 HashTableDel(CHashTable *table)
{//Free std system hash table, calling $LK,"HashDel",A="MN:HashDel"$() on entries.
I64 i;
CHashSrcSym *temph,*temph1;
if (!table) return;
for (i=0;i<=table->mask;i++) {
temph=table->body[i];
while (temph) {
temph1=temph->next;
HashDel(temph);
temph=temph1;
}
}
Free(table->body);
Free(table);
}
I64 HashTablePurge(CHashTable *table)
{//Eliminate ExportSysSyms that have been usurped.
I64 i,result=0;
CHashSrcSym *temph,*temph1,*temph2;
if (!table) return 0;
PUSHFD
CLI //Precaution
for (i=0;i<=table->mask;i++) {
temph=table->body[i];
while (temph) {
temph1=temph->next; //We delete only older ones
if (temph->type&(HTT_FUN|HTT_GLBL_VAR)) {
temph2=temph->next; //Older always later in chain
while (temph2) {
if ((temph2->type&HTT_EXPORT_SYS_SYM || temph2->type&HTG_TYPE_MASK==HTT_INVALID) &&
!StrCmp(temph2->str,temph->str)) {
if (temph2->type&HTG_TYPE_MASK==HTT_INVALID)
temph2->type=HTT_KEYWORD;//Won't delete HTT_INVALID
HashRemDel(temph2,table);
result++;
break;
}
temph2=temph2->next;
}
}
temph=temph1;
}
}
POPFD
return result;
}
CHashGeneric *HashGenericAdd(U8 *name,I64 type,I64 u0=0,I64 u1=0,I64 u2=0,CTask *task=NULL)
{//Add any type to task hash_table, 3 user_data values.
if (!task) task=Fs;
CHashGeneric *result=CAlloc(sizeof(CHashGeneric),task);
result->type=type;
result->user_data0=u0;
result->user_data1=u1;
result->user_data2=u2;
result->str=StrNew(name,task);
HashAdd(result,task->hash_table);
return result;
}
U0 HashSrcFileSet(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0)
{//Set $LK,"CHashSrcSym",A="MN:CHashSrcSym"$ link and help_index by cur lx pos.
CLexFile *tempf=lx->cur_lfn;
I64 line_num=tempf->line_num+line_num_offset;
if (line_num<1) line_num=1;
Free(h->src_link);
h->src_link=MStrPrint("FL:%s,%d",tempf->full_name,line_num);
if (Bt(&lx->opts,OPTf_KEEP_PRIVATE))
h->type|=HTF_PRIVATE;
Free(h->index);
if (lx->cur_help_index)
h->index=StrNew(lx->cur_help_index);
else
h->index=NULL;
}
CHashGeneric *HashPublic(U8 *st,I64 mask,Bool val=TRUE)
{//Mark a hash entry as public and $LK,"HashSrcFileSet",A="MN:HashSrcFileSet"$().
CHashGeneric *result;
if (result=HashFind(st,Fs->hash_table,mask)) {
if (val)
result->type|=HTF_PUBLIC;
else
result->type&=~HTF_PUBLIC;
if (result->type&HTG_SRC_SYM)
HashSrcFileSet(Fs->last_lex,result);
return result;
} else
return NULL;
}
I64 HashLstAdd(U8 *lst,I64 type,CHashTable *table)
{//Add a list to a hash table.
I64 i=0;
CHashGeneric *temph;
if (lst) {
while (*lst) {
if (*lst=='@')
lst++;
else
i++;
temph=CAlloc(sizeof(CHashGeneric));
temph->user_data0=i-1;
temph->str=StrNew(lst);
temph->type=type;
HashAdd(temph,table);
while (*lst++);
}
}
return i;
}
I64 HashDefineLstAdd(U8 *name,I64 type,CHashTable *table)
{//Add define list to a hash table. See $LK,"::/Adam/DolDoc/DocInit.CPP",A="FF:::/Adam/DolDoc/DocInit.CPP,HashDefineLstAdd"$.
CHashDefineStr *temph;
if (temph=HashFind(name,Fs->hash_table,HTT_DEFINE_STR))
return HashLstAdd(temph->data,type,table);
else
return 0;
}
I64 FramePtr(U8 *name,CTask *task=NULL)
{//Find entry in task->hash_table, Return user_data.
CHashGeneric *temph;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR))
return temph->user_data0;
else
return 0;
}
CHashGeneric *FramePtrAdd(U8 *name,I64 val=0,CTask *task=NULL)
{//Add named value to task->hash_table.
return HashGenericAdd(name,HTT_FRAME_PTR,val,0,0,task);
}
I64 FramePtrSet(U8 *name,I64 val,CTask *task=NULL)
{//Find hash entry in task->hash_table. Change user_data0.
CHashGeneric *temph;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR))
return LXchgI64(&temph->user_data0,val);
else
return 0;
}
I64 FramePtrDel(U8 *name,CTask *task=NULL)
{//Remove entry and delete.
CHashGeneric *temph;
I64 result=0;
if (!task) task=Fs;
if (temph=HashFind(name,task->hash_table,HTT_FRAME_PTR)) {
result=temph->user_data0;
HashRemDel(temph,task->hash_table);
}
return result;
}
Kernel/KLoad.CPP
+247
View File
@@ -0,0 +1,247 @@
U0 LoadOneImport(U8 **_src,U8 *module_base,I64 ld_flags)
{
U8 *src=*_src,*ptr2,*st_ptr;
I64 i,etype;
CHashExport *tempex=NULL;
CHashImport *tempiss;
Bool first=TRUE;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
if (*st_ptr) {
if (!first) {
*_src=st_ptr-5;
return;
} else {
first=FALSE;
if (!(tempex=HashFind(st_ptr,Fs->hash_table,HTG_ALL-HTT_IMPORT_SYS_SYM))) {
if (!(ld_flags & LDF_SILENT))
"Unresolved Reference:%s\n",st_ptr;
tempiss=CAlloc(sizeof(CHashImport));
tempiss->str=StrNew(st_ptr);
tempiss->type=HTT_IMPORT_SYS_SYM;
tempiss->module_header_entry=st_ptr-5;
tempiss->module_base=module_base;
HashAdd(tempiss,Fs->hash_table);
}
}
}
if (tempex) {
ptr2=module_base+i;
if (tempex->type & HTT_FUN)
i=tempex(CHashFun *)->executable_addr;
else if (tempex->type & HTT_GLBL_VAR)
i=tempex(CHashGlblVar *)->data_addr;
else
i=tempex->val;
switch (etype) {
case EIT_REL_I8: *ptr2(U8 *) =i-ptr2-1; break;
case EIT_IMM_U8: *ptr2(U8 *) =i; break;
case EIT_REL_I16: *ptr2(U16 *)=i-ptr2-2; break;
case EIT_IMM_U16: *ptr2(U16 *)=i; break;
case EIT_REL_I32: *ptr2(U32 *)=i-ptr2-4; break;
case EIT_IMM_U32: *ptr2(U32 *)=i; break;
case EIT_REL_I64: *ptr2(I64 *)=i-ptr2-8; break;
case EIT_IMM_I64: *ptr2(I64 *)=i; break;
}
}
}
*_src=src-1;
}
U0 SysSymImportsResolve(U8 *st_ptr,I64 ld_flags)
{
CHashImport *tempiss;
U8 *ptr;
while (tempiss=HashSingleTableFind(st_ptr,Fs->hash_table,HTT_IMPORT_SYS_SYM)) {
ptr=tempiss->module_header_entry;
LoadOneImport(&ptr,tempiss->module_base,ld_flags);
tempiss->type=HTT_INVALID;
}
}
U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
{
U8 *ptr2,*ptr3,*st_ptr;
I64 i,j,cnt,etype;
CHashExport *tempex=NULL;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_REL32_EXPORT:
case EIT_IMM32_EXPORT:
case EIT_REL64_EXPORT:
case EIT_IMM64_EXPORT:
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
if (etype==EIT_IMM32_EXPORT||etype==EIT_IMM64_EXPORT)
tempex->val=i;
else
tempex->val=i+module_base;
HashAdd(tempex,Fs->hash_table);
SysSymImportsResolve(st_ptr,ld_flags);
break;
case EIT_REL_I0...EIT_IMM_I64:
src=st_ptr-5;
LoadOneImport(&src,module_base,ld_flags);
break;
case EIT_ABS_ADDR:
if (ld_flags & LDF_NO_ABSS)
src+=i*sizeof(U32);
else {
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(U32 *)+=module_base;
}
}
break;
sub_switch_start:
case EIT_CODE_HEAP:
ptr3=MAlloc(*src(I32 *)++,Fs->code_heap);
break;
case EIT_ZEROED_CODE_HEAP:
ptr3=CAlloc(*src(I32 *)++,Fs->code_heap);
break;
sub_switch_end:
if (*st_ptr) {
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
tempex->val=ptr3;
HashAdd(tempex,Fs->hash_table);
}
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(I32 *)+=ptr3;
}
break;
sub_switch_start:
case EIT_DATA_HEAP:
ptr3=MAlloc(*src(I64 *)++);
break;
case EIT_ZEROED_DATA_HEAP:
ptr3=CAlloc(*src(I64 *)++);
break;
sub_switch_end:
if (*st_ptr) {
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
tempex->val=ptr3;
HashAdd(tempex,Fs->hash_table);
}
cnt=i;
for (j=0;j<cnt;j++) {
ptr2=module_base+*src(U32 *)++;
*ptr2(I64 *)+=ptr3;
}
break;
}
}
}
U0 LoadPass2(U8 *src,U8 *module_base,I64)
{
U8 *st_ptr;
I64 i,etype;
while (etype=*src++) {
i=*src(U32 *)++;
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_MAIN:
Call(i+module_base);
break;
case EIT_ABS_ADDR:
src+=sizeof(U32)*i;
break;
case EIT_CODE_HEAP:
case EIT_ZEROED_CODE_HEAP:
src+=4+sizeof(U32)*i;
break;
case EIT_DATA_HEAP:
case EIT_ZEROED_DATA_HEAP:
src+=8+sizeof(U32)*i;
break;
}
}
}
CBinFile *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR)
{//Load a .BIN file module into memory.
//bfh_addr==INVALID_PTR means don't care what load addr.
U8 *fbuf,*module_base,*absname;
I64 size,module_align,misalignment;
CBinFile *bfh;
fbuf=DftExt(filename,"BIN.Z");
if (!(bfh=FileRead(fbuf,&size))) {
Free(fbuf);
return NULL;
}
//See $LK,"Patch Table Generation",A="FF:::/Compiler/CMain.CPP,EIT_ABS_ADDR"$
module_align=1<<bfh->module_align_bits;
if (!module_align || bfh->bin_signature!=BIN_SIGNATURE_VAL) {
Free(bfh);
Free(fbuf);
throw('BinModul');
}
if (bfh_addr==INVALID_PTR) {
if (bfh->module_org==INVALID_PTR) {
misalignment=module_align-sizeof(CBinFile);
if (misalignment<0)
misalignment&=module_align-1;
if (Fs->code_heap!=Fs->data_heap) {
if (module_align<16)
module_align=16;
bfh_addr=MAllocAligned(size,module_align,Fs->code_heap,misalignment);
} else if (module_align>8)
bfh_addr=MAllocAligned(size,module_align,,misalignment);
else {//Less than 2Gig system memory
bfh_addr=bfh;
goto lo_skip; //File is already in code heap area, don't copy.
}
} else
bfh_addr=bfh->module_org;
}
MemCpy(bfh_addr,bfh,size);
Free(bfh);
lo_skip:
module_base=bfh_addr(U8 *)+sizeof(CBinFile);
absname=FileNameAbs(fbuf);
Free(fbuf);
fbuf=StrNew(absname);
FileExtRem(fbuf);
if (fbuf[1]==':' && StrLen(fbuf)>2)
HashGenericAdd(fbuf+2,HTT_MODULE|HTF_PUBLIC,bfh_addr);
LoadPass1(bfh_addr(U8 *)+bfh_addr->patch_table_offset,module_base,ld_flags);
if (!(ld_flags&LDF_JUST_LOAD))
LoadPass2(bfh_addr(U8 *)+bfh_addr->patch_table_offset,module_base,ld_flags);
Free(absname);
Free(fbuf);
return bfh_addr;
}
U0 LoadKernel()
{
HashGenericAdd(KERNEL_MODULE_NAME,HTT_MODULE|HTF_PUBLIC,sys_boot_base-sizeof(CBinFile));
//Abs patches done here $LK,"CPatchTableAbsAddr",A="FF:D:/Kernel/KStart.CPP,CPatchTableAbsAddr"$.
LoadPass1(sys_boot_patch_table_base,sys_boot_base,LDF_NO_ABSS|LDF_SILENT);
//No main routines
// LoadPass2(sys_boot_patch_table_base,sys_boot_base,0);
}
Kernel/Math1a.CPP → Kernel/KMathA.CPP
View File
File renamed without changes.
Kernel/KMathB.CPP
+144
View File
@@ -0,0 +1,144 @@
F64 Clamp(F64 num,F64 lo,F64 hi)
{//Clamp to F64 [] range.
if (num<lo)
return lo;
if (num>hi)
return hi;
return num;
}
F64 Min(F64 n1,F64 n2)
{//Min of two F64s.
if (n1<=n2)
return n1;
else
return n2;
}
F64 Max(F64 n1,F64 n2)
{//Max of two F64s.
if (n1>=n2)
return n1;
else
return n2;
}
F64 Pow10I64(I64 i)
{//F64 integer powers of ten.
if (i>308)
return ì;
else if (i<-308)
return 0.0;
else
return pow10_I64[i+309];
}
U64 FloorU64(U64 num,U64 to)
{//Integer multiples of num.
return num-num%to;
}
U64 CeilU64(U64 num,U64 to)
{//Integer multiples of num.
num+=to-1;
return num-num%to;
}
I64 RoundI64(I64 num,I64 to)
{//Integer multiples of num.
return num-num%to;
}
I64 FloorI64(I64 num,I64 to)
{//Integer multiples of num.
if (num>=0)
return num-num%to;
else {
num++;
return num-num%to-to;
}
}
I64 CeilI64(I64 num,I64 to)
{//Integer multiples of num.
if (num>=0) {
num+=to-1;
return num-num%to;
} else {
num+=to-1;
return num-num%to-to;
}
}
//See $LK,"::/Doc/Credits.TXT"$.
I16 RandI16()
{//Random I16.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=result;
return result.i16[0];
}
U16 RandU16()
{//Random U16.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=result;
return result.u16[0];
}
I32 RandI32()
{//Random I32.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=result;
return result.i32[0];
}
U32 RandU32()
{//Random U32.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=result;
return result.u32[0];
}
I64 RandI64()
{//Random I64.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=1664525*result+1013904223;
return result<<32+Fs->rand_seed&0xFFFFFFFF;
}
U64 RandU64()
{//Random U64.
I64 result=1664525*Fs->rand_seed+1013904223;
if (!Bt(&Fs->task_flags,TASKf_NONTIMER_RAND))
result^=GetTSC>>4;
Fs->rand_seed=1664525*result+1013904223;
return result<<32+Fs->rand_seed&0xFFFFFFFF;
}
F64 Rand()
{//Random F64.
I64 result=RandI64&0x3FFFFFFFFFFFFFFF;
return result/ToF64(0x4000000000000000);
}
I64 Seed(I64 seed=0,CTask *task=NULL)
{//Set $LK,"Rand",A="MN:Rand"$() seed. Zero for timer-based.
if (!task) task=Fs;
if (seed) {
LBts(&task->task_flags,TASKf_NONTIMER_RAND);
return task->rand_seed=seed;
} else {
LBtr(&task->task_flags,TASKf_NONTIMER_RAND);
return task->rand_seed=GetTSC>>4;
}
}
Kernel/Misc1a.CPP → Kernel/KMisc.CPP
+13 -9
View File
@@ -136,8 +136,12 @@ Bool Blink(F64 Hz=2.5)
U0 BusyWait(I64 æS)
{//Loosely timed.
I64 i;
for (i=0;i<æS;i++)
PortNop;
if (cnts.HPET_freq) {
i=HPET+cnts.HPET_freq*æS/1000000;
while (HPET<i);
} else
for (i=0;i<æS;i++)
PortNop;
}
U0 SleepUntil(I64 wake_jiffy)
@@ -158,17 +162,17 @@ U0 Sleep(I64 mS)
U0 Snd(F64 freq)
{//Play freq. Zero means off.
I64 p;
I64 period;
CSndData *d;
if (!Bt(&sys_semas[SYS_SEMA_MUTE],0) &&
!LBts(&sys_semas[SYS_SEMA_SND],0)) {
!LBts(&sys_semas[SYS_SEMA_SND],0)) { //Mutex. Just throw-out if in use
if (freq!=snd.freq) {
snd.freq=freq;
if (0<freq<=20000) {
p=SYS_TIMER_FREQ/freq;
period=SYS_TIMER_FREQ/freq;
OutU8(0x43,0xB6);
OutU8(0x42,p);
OutU8(0x42,p.u8[1]);
OutU8(0x42,period);
OutU8(0x42,period.u8[1]);
OutU8(0x61,3|InU8(0x61));
} else
OutU8(0x61,InU8(0x61)&~3);
@@ -216,7 +220,7 @@ Bool IsMute()
return Bt(&sys_semas[SYS_SEMA_MUTE],0);
}
Bool Silent(Bool val)
Bool Silent(Bool val=ON)
{//Turns-off StdOut console text output, not sound.
return LBEqu(&Fs->display_flags,DISPLAYf_SILENT,val);
}
@@ -300,7 +304,7 @@ U0 CtrlAltD(I64)
U0 CtrlAltE(I64)
{
SpawnUser;
User;
}
U0 CtrlAltF(I64)
Kernel/KStart.CPP
+74 -115
View File
@@ -6,7 +6,7 @@ It continues here: $LK,"Kernel",A="FF:::/Kernel/KEnd.CPP,U0 Kernel"$.
The boot loader jumps here, in real-mode (16-bit).
It actually jumps to the $LK,"CBinFile",A="MN:CBinFile"$ which is placed
just before this $LK,"generated by the compiler",A="FF:::/Compiler/CmpMain.CPP,16 ALIGN"$.
just before this $LK,"generated by the compiler",A="FF:::/Compiler/CMain.CPP,16 ALIGN"$.
The header begins with a short jmp to
the start of this file's code which begins
with the following small jump past some data.
@@ -15,28 +15,28 @@ This file is first in the Kernel image
because it is #included first. $LK,"Kernel.PRJ",A="FF:::/Kernel/Kernel.PRJ,KStart:1"$
*/
USE16
SYS_KERNEL_START1:: //This must match $LK,"CKernel",A="MN:CKernel"$.
JMP U16 SYS_KERNEL_START2
SYS_KERNEL:: //This must match $LK,"CKernel",A="MN:CKernel"$.
JMP U16 BSP_16BIT_INIT
//************************************
// ASM Global vars required for 16-bit start-up
ALIGN 4,OC_NOP
SYS_BOOT_BASE:: DU32 0; //Fixed offset from start used by reboot
SYS_BOOT_SRC:: DU32 BOOT_SRC_NULL;
SYS_BOOT_PATCH_TABLE_BASE:: DU32 0;
SYS_RUN_LEVEL:: DU32 0;
#exe {StreamPrint("SYS_COMPILE_TIME:: DU64 0x%X;",Now);}
//See $LK,"BootCdProbe",A="MN:BootCdProbe"$
#assert SYS_COMPILE_TIME+8+sizeof(CBinFile)<CD_BLK_SIZE
#assert SYS_COMPILE_TIME+sizeof(CDate)+sizeof(CBinFile)<CD_BLK_SIZE
SYS_OS_32START:: DU32 SYS_INIT_OS;
SYS_BOOT_CODE:: DU32 0xFF;
SYS_BOOT_BASE:: DU32 0; //Offset from start used by reboot
SYS_MEM_E801:: DU16 0,0;
SYS_MEM_E820:: DU8 MEM_NUM_E820_ENTRIES*MEM_E820_ENTRY_SIZE DUP (0);
ALIGN 16,OC_NOP
SYS_GDT:: //See $LK,"CGDT",A="MN:CGDT"$
GDT_NULL: DU64 0,0;
GDT_BOOT_DS: DU64 0,0; //Gets filled-in
GDT_BOOT_CS: DU64 0,0; //Gets filled-in
GDT_BOOT_DS: DU64 0x00CF92000000FFFF,0; //Gets patched.
GDT_BOOT_CS: DU64 0x00CF9A000000FFFF,0; //Gets patched.
GDT_CS32: DU64 0x00CF9A000000FFFF,0;
GDT_CS64: DU64 0x00209A0000000000,0; //The $LK,"Charter",A="FI:::/Doc/Charter.TXT"$ says just ring0.
GDT_CS64_RING3: DU64 0x0020FA0000000000,0; //$LK,"Ring3",A="FI:::/Demo/Lectures/Ring3.CPP"$, in case you want to play around.
@@ -46,21 +46,19 @@ GDT_TR: DU8 MP_MAX_PROCESSORS*16 DUP(0);
GDT_TR_RING3: DU8 MP_MAX_PROCESSORS*16 DUP(0);
#assert $$-SYS_GDT==sizeof(CGDT)
SYS_BIOS_GR_MODE:: DU16 0;
SYS_PCI_BUSSES:: DU16 0;
#assert $$-SYS_KERNEL_START1==sizeof(CKernel)-sizeof(CBinFile)
SYS_RUN_LEVEL:: DU32 0;
SYS_TEMP_PTR:: DU16 0;
SYS_GDT_PTR:: DU16 sizeof(CGDT)-1;
DU64 0;
SYS_PCI_BUSSES:: DU16 0;
#assert $$-SYS_KERNEL==sizeof(CKernel)-sizeof(CBinFile)
//************************************
SYS_KERNEL_START2::
//EBX is SYS_BOOT_CODE (val passed from boot blk)
BSP_16BIT_INIT::
//EBX is $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. (Val passed from boot blk, $LK,"BootHD",A="FF:::/Adam/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootCD",A="FF:::/Adam/Boot/BootCD.CPP,BOOT_SRC_CDROM"$, & $LK,"BootRAM",A="FF:::/Adam/Boot/Boot.CPP,BOOT_SRC_RAM"$.)
MOV AX,(BOOT_RAM_LIMIT-BOOT_STK_SIZE)/16
MOV SS,AX
MOV SP,BOOT_STK_SIZE
PUSH EBX //will be SYS_BOOT_CODE
MOV AX,VGA_TEXT_MEM_BASE/16
PUSH EBX //Will be $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. See $LK,"BootHD",A="FF:::/Adam/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootCD",A="FF:::/Adam/Boot/BootCD.CPP,BOOT_SRC_CDROM"$ & $LK,"BootRAM",A="FF:::/Adam/Boot/Boot.CPP,BOOT_SRC_RAM"$.
MOV AX,VGAM_TEXT/16
MOV ES,AX
MOV U32 ES:[0],'O'+BLUE<<12+('S'+GREEN<<12)<<16
@@ -71,26 +69,24 @@ GET_IP: POP BX
MOV AX,CS
ADD AX,BX
PUSH AX
PUSH U16 TEMPLEOS_CONT_START
PUSH U16 @@05
RETF
TEMPLEOS_CONT_START:
STI
@@05: STI
MOV AX,CS
MOV DS,AX
MOV U32 [SYS_RUN_LEVEL],RLF_16BIT
MOV BX,0x12 //640x480 16 color
MOV U16 [SYS_BIOS_GR_MODE],BX
MOV AX,0x4F02
MOV BX,0x12 //640x480 16 color
#exe {
if (!kernel_cfg->opts[CFG_TEXT_MODE])
StreamPrint("INT 0x10"); //Enable VGA
};
CMP AX,0x004F
JE @@10
MOV U16 [SYS_BIOS_GR_MODE],0 //failed
JNE @@10 //Jmp if fail
BTS U32 [SYS_RUN_LEVEL],RLf_VGA
@@10:
//Get mem maps
@@ -138,52 +134,33 @@ TEMPLEOS_CONT_START:
OR AL,2
OUT 0x92,AL
CLD //Start with known regs
POP U32 [SYS_BOOT_SRC] //See $LK,"BootHD",A="FF:::/Adam/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootCD",A="FF:::/Adam/Boot/BootCD.CPP,BOOT_SRC_CDROM"$, & $LK,"BootRAM",A="FF:::/Adam/Boot/Boot.CPP,BOOT_SRC_RAM"$.
CLD
XOR EAX,EAX
MOV AX,CS
MOV DS,AX
MOV ES,AX
MOV FS,AX
MOV GS,AX
XOR EAX,EAX
XOR EBX,EBX
XOR ECX,ECX
XOR EDX,EDX
XOR ESI,ESI
XOR EDI,EDI
XOR EBP,EBP
XOR EAX,EAX
MOV AX,CS
SHL EAX,4
MOV U32 [SYS_BOOT_BASE],EAX
POP U32 [SYS_BOOT_CODE]
MOV BX,CS
SUB BX,sizeof(CBinFile)/16
MOV DX,CS
SUB DX,sizeof(CBinFile)/16
#assert !(sizeof(CBinFile)&15)
MOV GS,BX
MOV EBX,U32 GS:[CBinFile.patch_table_offset]
ADD EAX,EBX
SUB EAX,sizeof(CBinFile)
MOV U32 [SYS_BOOT_PATCH_TABLE_BASE],EAX
MOV GS,DX
MOV EDX,EAX
ADD EDX,U32 GS:[CBinFile.patch_table_offset]
SUB EDX,sizeof(CBinFile)
MOV U32 [SYS_BOOT_PATCH_TABLE_BASE],EDX
MOV U32 [GDT_BOOT_DS],0x0000FFFF
MOV U32 [GDT_BOOT_DS+4],0x0CF9200
MOV U32 [GDT_BOOT_CS],0x0000FFFF
MOV U32 [GDT_BOOT_CS+4],0x0CF9A00
MOV EAX,U32 [SYS_BOOT_BASE]
ADD U32 [GDT_BOOT_DS+2],EAX
ADD U32 [GDT_BOOT_CS+2],EAX
ADD EAX,I32 SYS_GDT
MOV U32 [SYS_GDT_PTR+CSysLimitBase.base],EAX
LGDT U32 [SYS_GDT_PTR]
//Set-up ptr to limit and base of GDT.
MOV U16 [SYS_TEMP_PTR],sizeof(CGDT)-1
MOV EAX,U32 [SYS_BOOT_BASE]
ADD EAX,SYS_GDT
MOV U32 [SYS_TEMP_PTR+2],EAX
MOV U16 [SYS_TEMP_PTR+6],0
LGDT U32 [SYS_TEMP_PTR]
MOV EAX,SYS_START_CR0
MOV_CR0_EAX
@@ -195,8 +172,8 @@ The assembler doesn't support far jumps so we hand code it.
To complete the switch to 32-bit mode, we have to load
the code segment with a far jump.
*/
DU8 0x66,0xEA; //JMP CGDT.boot_cs:SYS_INIT_OS
DU32 SYS_INIT_OS;
DU8 0x66,0xEA; //JMP CGDT.boot_cs:BSP_32BIT_INIT
DU32 BSP_32BIT_INIT;
DU16 CGDT.boot_cs;
#assert $$+16<=0xFFFF
@@ -254,7 +231,7 @@ SYS_CACHE_LINE_WIDTH:: DU64 DFT_CACHE_LINE_WIDTH;
SYS_SEMAS:: DU8 NUM_SYS_SEMAS*SEMA_STRUCT_SIZE DUP(0);
//************************************
ALIGN 16,OC_NOP
SYS_INIT_OS:: //Entry point for RAM reboots.
BSP_32BIT_INIT:: //Entry point for $LK,"RAMReboot",A="MN:RAMReboot"$.
PUSH U32 SYS_START_RFLAGS
POPFD
MOV EAX,SYS_START_CR0
@@ -262,26 +239,9 @@ SYS_INIT_OS:: //Entry point for RAM reboots.
MOV AX,CGDT.boot_ds //LOAD DS SELECTOR
MOV DS,AX
MOV ES,AX
MOV EAX,U32 [SYS_RUN_LEVEL]
AND EAX,RLF_16BIT
OR EAX,RLF_32BIT
MOV U32 [SYS_RUN_LEVEL],EAX
//Patch abs addresses
BTS U32 [SYS_RUN_LEVEL],RLf_32BIT
MOV ESI,U32 [SYS_BOOT_PATCH_TABLE_BASE]
MOV EDI,U32 [SYS_BOOT_BASE]
MOV AX,CGDT.ds
MOV DS,AX
MOV ES,AX
MOV ECX,U32 CPatchTableAbsAddr.abs_addres_cnt[ESI]
LEA ESI,U32 CPatchTableAbsAddr.abs_addres[ESI]
@@05: LODSD
ADD EAX,EDI
ADD U32 [EAX],EDI
LOOP @@05
MOV AX,CGDT.ds
MOV DS,AX
@@ -291,13 +251,19 @@ SYS_INIT_OS:: //Entry point for RAM reboots.
MOV SS,AX
MOV ESP,BOOT_RAM_LIMIT //Temp Stk
DU8 0xEA; //JMP CGDT.cs32:SYS_CONT_INIT_OS
DU32 SYS_CONT_INIT_OS;
//Patch abs addresses
MOV ECX,U32 CPatchTableAbsAddr.abs_addres_cnt[ESI]
LEA ESI,U32 CPatchTableAbsAddr.abs_addres[ESI]
@@05: LODSD
ADD EAX,EDI
ADD U32 [EAX],EDI
LOOP @@05
DU8 0xEA; //JMP CGDT.cs32:@@10
DU32 @@10;
DU16 CGDT.cs32;
SYS_CONT_INIT_OS::
LOCK
BTS U32 [SYS_RUN_LEVEL],RLf_PATCHED
@@10: BTS U32 [SYS_RUN_LEVEL],RLf_PATCHED
CALL SYS_FIND_BIOS32_SERVICE_DIR
CALL SYS_FIND_PCI_SERVICES
@@ -305,11 +271,9 @@ SYS_CONT_INIT_OS::
MOV U32 [SYS_HEAP_BASE],SYS_FIXED_AREA+sizeof(CSysFixedArea)
CALL SYS_INIT_MEM
PUSH U32 0
CALL INIT_EM64T
USE64
LOCK
BTS U32 [SYS_RUN_LEVEL],RLf_64BIT
PUSH U32 0 //Return from next call will be 64-bit
CALL SYS_EM64T
USE64 BTS U32 [SYS_RUN_LEVEL],RLf_64BIT
FNINIT
MOV RAX,SYS_FIXED_AREA+CSysFixedArea.init_fpu_mmx
@@ -322,14 +286,13 @@ USE64
CALL &CPUStructInit
CALL SET_GS_BASE
//Init Adam heap ctrl
//Init Adam HeapCtrl
MOV EDI,U32 SYS_FIXED_AREA+CSysFixedArea.adam_hc
MOV EAX,U32 SYS_FIXED_AREA+CSysFixedArea.adam_bp
MOV U64 CHeapCtrl.bp[RDI],RAX
MOV U32 CHeapCtrl.hc_signature[RDI],HEAP_CTRL_SIGNATURE_VAL
LEA RAX,U64 CHeapCtrl.next_um-CMemUsedAllocated.next[RDI]
LEA RAX,U64 CHeapCtrl.next_um-CMemUsed.next[RDI]
MOV U64 CHeapCtrl.next_um[RDI],RAX
MOV U64 CHeapCtrl.last_um[RDI],RAX
@@ -340,7 +303,6 @@ USE64
MOV U32 CTask.task_signature[RAX],TASK_SIGNATURE_VAL
MOV U32 CTask.task_in_que_signature[RAX],TASK_IN_QUE_SIGNATURE_VAL
LOCK
BTS U32 [SYS_RUN_LEVEL],RLf_BOOT_HEAP
PUSH ADAM_STK
@@ -353,7 +315,7 @@ USE64
//************************************
USE32
INIT_EM64T:
SYS_EM64T:: //Switch to long 64-bit mode
MOV_EAX_CR4
OR EAX,0xB0
MOV_CR4_EAX
@@ -370,24 +332,20 @@ INIT_EM64T:
BTS EAX,31 //enable paging (required for 64-bit mode)
MOV_CR0_EAX
DU8 0xEA; //JMP CGDT.cs64:EM64T_PART3
DU32 EM64T_PART3;
DU8 0xEA; //JMP CGDT.cs64:@@05
DU32 @@05;
DU16 CGDT.cs64;
USE64
EM64T_PART3:
@@05: MOV AX,CGDT.ds
MOV DS,AX
MOV ES,AX
MOV SS,AX
MOV FS,AX
MOV GS,AX
RET
//************************************
SYS_RESTART_KERNEL::
XOR RDI,RDI
MOV EDI,U32 SYS_BOOT_BASE
MOV EDI,U32 [RDI]
XOR RSI,RSI
MOV ESI,U32 SYS_OS_32START
MOV ESI,U32 [RSI]
ADD ESI,EDI
SYS_RAM_REBOOT:: //This gets copied high. $LK,"SYS_RAM_REBOOT",A="FF:::/Adam/Boot/Boot.CPP,SYS_RAM_REBOOT:2"$
PUSH U32 CGDT.ds //stk seg
PUSH U32 BOOT_RAM_LIMIT //stk
PUSH U32 0 //flags
@@ -396,8 +354,8 @@ SYS_RESTART_KERNEL::
PUSH RAX
IRET
USE32
@@10:
WBINVD
@@10: WBINVD
//disable paging
MOV_EAX_CR0
BTR EAX,31
@@ -408,8 +366,9 @@ USE32
XOR EAX,EAX
WRMSR
MOV EBX,BOOT_CODE_RAM
JMP ESI
MOV EBX,BOOT_SRC_RAM
MOV EAX,I32 BSP_32BIT_INIT
JMP EAX
USE64
SYS_RESTART_KERNEL_END::
SYS_RAM_REBOOT_END::
}
Kernel/Utils1a.CPP → Kernel/KUtils.CPP
View File
File renamed without changes.
Kernel/KbdMouse/InputPointer.CPP
+2 -2
View File
@@ -40,7 +40,7 @@ U0 IPVarsUpdate(I64 x,I64 y,I64 z,Bool l,Bool r)
LBEqu(&kbd.scan_code,SCf_IP_R_DOWN,ip.rb);
}
U0 SetIP(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64)
U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64)
{//Note: Generates a message.
Bool old_preempt=Preempt(OFF);
if (!(0<=x<GR_WIDTH))
@@ -61,7 +61,7 @@ U0 SetIP(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64)
IPVarsUpdate(x,y,z,l,r);
switch (ip.dev) {
case IP_MOUSE:
SetMouseIP(x,y,z,l,r);
MouseIPSet(x,y,z,l,r);
break;
}
Preempt(old_preempt);
Kernel/KbdMouse/Keyboard.CPP
+53 -91
View File
@@ -80,7 +80,7 @@ U0 KbdMouseCmdAck(U8 val)
throw;
}
U0 SetTypeMatic(U8 delay)
U0 KbdTypeMatic(U8 delay)
{//Set speed of repeated keys.
try {
KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
@@ -289,15 +289,13 @@ U8 *ScanCode2KeyName(I64 sc)
return StrNew(buf);
}
I64 KbdBuildSC(U8 raw_byte,U8 *_last_raw_byte,I64 *_last_sc,
Bool *_set_LEDs,Bool *_ctrl_alt)
U0 KbdBuildSC(U8 raw_byte,Bool in_irq,U8 *_last_raw_byte,I64 *_last_sc)
{
I64 sc_flags,sc,sc2,sc_raw;
*_set_LEDs=FALSE;
*_ctrl_alt=FALSE;
I64 ch,sc_flags,sc,sc2,sc_raw;
Bool set_LEDs=FALSE;
if (raw_byte==0xE0) {
*_last_raw_byte=raw_byte;
return 0;
return;
} else {
sc=raw_byte;
BEqu(&sc,SCf_E0_PREFIX,*_last_raw_byte==0xE0);
@@ -317,63 +315,30 @@ I64 KbdBuildSC(U8 raw_byte,U8 *_last_raw_byte,I64 *_last_sc,
if (sc&SCF_KEY_UP)
switch (sc&~SCF_KEY_UP) {
case SC_SHIFT: sc_flags&=~SCF_SHIFT; goto kb_new_key_done;
case SC_CTRL: sc_flags&=~SCF_CTRL; goto kb_new_key_done;
case SC_ALT: sc_flags&=~SCF_ALT; goto kb_new_key_done;
case SC_DELETE: sc_flags&=~SCF_DELETE; goto kb_new_key_done;
case SC_INS: sc_flags&=~SCF_INS; goto kb_new_key_done;
case SC_CAPS:
sc_flags^=SCF_CAPS;
*_set_LEDs=TRUE;
goto kb_new_key_done;
case SC_NUM:
sc_flags^=SCF_NUM;
*_set_LEDs=TRUE;
goto kb_new_key_done;
case SC_SCROLL:
sc_flags^=SCF_SCROLL;
*_set_LEDs=TRUE;
goto kb_new_key_done;
case SC_SHIFT: sc_flags&=~SCF_SHIFT; break;
case SC_CTRL: sc_flags&=~SCF_CTRL; break;
case SC_ALT: sc_flags&=~SCF_ALT; break;
case SC_DELETE: sc_flags&=~SCF_DELETE; break;
case SC_INS: sc_flags&=~SCF_INS; break;
case SC_CAPS: sc_flags^=SCF_CAPS; set_LEDs=TRUE; break;
case SC_NUM: sc_flags^=SCF_NUM; set_LEDs=TRUE; break;
case SC_SCROLL: sc_flags^=SCF_SCROLL; set_LEDs=TRUE; break;
}
else
switch (sc) {
case SC_SHIFT: sc_flags|=SCF_SHIFT; goto kb_new_key_done;
case SC_CTRL: sc_flags|=SCF_CTRL; goto kb_new_key_done;
case SC_ALT: sc_flags|=SCF_ALT; goto kb_new_key_done;
case SC_DELETE: sc_flags|=SCF_DELETE; goto kb_new_key_done;
case SC_INS: sc_flags|=SCF_INS; goto kb_new_key_done;
case SC_CAPS: goto kb_new_key_done;
case SC_NUM: goto kb_new_key_done;
case SC_SCROLL: goto kb_new_key_done;
case SC_SHIFT: sc_flags|=SCF_SHIFT; break;
case SC_CTRL: sc_flags|=SCF_CTRL; break;
case SC_ALT: sc_flags|=SCF_ALT; break;
case SC_DELETE: sc_flags|=SCF_DELETE; break;
case SC_INS: sc_flags|=SCF_INS; break;
}
sc_flags|=SCF_NEW_KEY;
sc=sc_flags|sc|(sc_flags|sc_raw)<<32;
if (sc_flags & SCF_CTRL && sc_flags & SCF_ALT) {
sc_flags&=~SCF_NEW_KEY;
*_ctrl_alt=TRUE;
} else {
kb_new_key_done:
sc_flags|=SCF_NEW_KEY;
}
return *_last_sc=sc_flags|sc|(sc_flags|sc_raw)<<32;
}
U0 KbdPktRead()
{
static U8 last_raw_byte=0;
static I64 last_sc=0;
U8 raw_byte;
I64 ch,sc;
Bool set_LEDs,ctrl_alt;
if (GetTSC>kbd.timestamp+cnts.time_stamp_freq>>3)
FifoU8Flush(kbd.fifo);
kbd.timestamp=GetTSC;
raw_byte=InU8(KBD_PORT);
sc=KbdBuildSC(raw_byte,&last_raw_byte,&last_sc,&set_LEDs,&ctrl_alt);
if (ctrl_alt && sc) {
if (!(sc & SCF_KEY_UP)) {
if (sc&255==SC_DELETE)
CtrlAltDel(last_sc);
CtrlAltDel(sc);
else {
if (sc&255==SC_ESC)
ch='e';
@@ -381,14 +346,32 @@ U0 KbdPktRead()
ch='t';
else
ch=ScanCode2Char(sc&255);
if ('a'<=ch<='z' && keydev.fp_ctrl_alt_let_cbs[ch-'a'] &&
Bt(&keydev.ctrl_alt_let_in_irq_flags,ch-'a')) {
(*keydev.fp_ctrl_alt_let_cbs[ch-'a'])(last_sc);
return;
if ('a'<=ch<='z') {
sc&=~(SCF_NEW_KEY|SCF_NEW_KEY<<32);
kbd.last_down_scan_code=sc;
if (keydev.fp_ctrl_alt_let_cbs[ch-'a'] &&
Bt(&keydev.ctrl_alt_let_in_irq_flags,ch-'a')==in_irq) {
(*keydev.fp_ctrl_alt_let_cbs[ch-'a'])(sc);
}
}
}
}
}
if (set_LEDs && !in_irq)
KbdSetLEDs(sc);
*_last_sc=sc;
}
U0 KbdPktRead()
{
static U8 last_raw_byte=0;
static I64 last_sc=0;
U8 raw_byte;
if (GetTSC>kbd.timestamp+cnts.time_stamp_freq>>3)
FifoU8Flush(kbd.fifo);
kbd.timestamp=GetTSC;
raw_byte=InU8(KBD_PORT);
KbdBuildSC(raw_byte,TRUE,&last_raw_byte,&last_sc);
if (!FifoU8Cnt(kbd.fifo)) {
FifoU8Ins(kbd.fifo,raw_byte);
if (raw_byte!=0xE0) {
@@ -415,7 +398,7 @@ interrupt U0 KbdIntHandler()
KbdPktRead;
}
U0 SetCtrlAltLetCB(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE)
U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE)
{//Set callback for <CTRL-ALT-letter>.
ch=ToUpper(ch)-'A';
if (ch<26) {
@@ -442,45 +425,24 @@ U0 KbdInit()
IntEntrySet(0x21,&KbdIntHandler);
OutU8(0x21,InU8(0x21)&~2);
SetCtrlAltLetCB('C',&CtrlAltC,"Sys/Break Execution",TRUE);
SetCtrlAltLetCB('D',&CtrlAltD,"Sys/Enter Debugger",TRUE);
SetCtrlAltLetCB('E',&CtrlAltE,"Sys/Spawn New User Task");
SetCtrlAltLetCB('F',&CtrlAltF,"Sys/VGA Flush",TRUE);
SetCtrlAltLetCB('M',&CtrlAltM,"Sys/Toggle Mute");
SetCtrlAltLetCB('T',&CtrlAltT,"Sys/Switch Focus to Next Task",TRUE);
SetCtrlAltLetCB('X',&CtrlAltX,"Sys/Kill Focused Task",TRUE);
CtrlAltLetCBSet('C',&CtrlAltC,"Sys/Break Execution",TRUE);
CtrlAltLetCBSet('D',&CtrlAltD,"Sys/Enter Debugger",TRUE);
CtrlAltLetCBSet('E',&CtrlAltE,"Sys/Spawn New User Task");
CtrlAltLetCBSet('F',&CtrlAltF,"Sys/VGA Flush",TRUE);
CtrlAltLetCBSet('M',&CtrlAltM,"Sys/Toggle Mute");
CtrlAltLetCBSet('T',&CtrlAltT,"Sys/Switch Focus to Next Task",TRUE);
CtrlAltLetCBSet('X',&CtrlAltX,"Sys/Kill Focused Task",TRUE);
}
U0 KbdHandler()
{
static U8 last_raw_byte=0;
U8 raw_byte;
Bool set_LEDs,ctrl_alt;
I64 ch,sc;
FifoU8Rem(kbd.fifo2,&raw_byte);
sc=KbdBuildSC(raw_byte,&last_raw_byte,&kbd.scan_code,&set_LEDs,&ctrl_alt);
if (set_LEDs)
KbdSetLEDs(sc);
KbdBuildSC(raw_byte,FALSE,&last_raw_byte,&kbd.scan_code);
if (raw_byte==0xE0) {
FifoU8Rem(kbd.fifo2,&raw_byte);
sc=KbdBuildSC(raw_byte,&last_raw_byte,&kbd.scan_code,&set_LEDs,&ctrl_alt);
if (set_LEDs)
KbdSetLEDs(sc);
}
if (ctrl_alt) {
if (!(sc & SCF_KEY_UP)) {
if (sc&255==SC_ESC)
ch='e';
else if (sc&255==SC_TAB)
ch='t';
else
ch=ScanCode2Char(sc&255);
if ('a'<=ch<='z' && keydev.fp_ctrl_alt_let_cbs[ch-'a'] &&
!Bt(&keydev.ctrl_alt_let_in_irq_flags,ch-'a'))
(*keydev.fp_ctrl_alt_let_cbs[ch-'a'])(kbd.scan_code);
}
return;
KbdBuildSC(raw_byte,FALSE,&last_raw_byte,&kbd.scan_code);
}
if (Btr(&kbd.scan_code,SCf_NEW_KEY)) {
Btr(&kbd.scan_code,32+SCf_NEW_KEY);
Kernel/KbdMouse/Mouse.CPP
+3 -3
View File
@@ -127,7 +127,7 @@ Bool MouseRst()
return result;
}
U0 SetMouseSpeed()
U0 MouseSpeedSet()
{
I64 dd,temp;
if ((dd=SqrI64(mouse_last.pos.x-mouse.pos.x)+SqrI64(mouse_last.pos.y-mouse.pos.y)) &&
@@ -164,7 +164,7 @@ U0 MouseUpdatePost()
if (mouse.pos.x!=mouse_last.pos.x || mouse.pos.y!=mouse_last.pos.y || mouse.pos.z!=mouse_last.pos.z) {
mouse.evt=TRUE;
SetMouseSpeed;
MouseSpeedSet;
} else
for (i=0;i<5;i++)
if (mouse.buttons[i]!=mouse_last.buttons[i]) {
@@ -210,7 +210,7 @@ U0 MouseHandler()
MouseUpdatePost;
}
U0 SetMouseIP(I64 x,I64 y,I64 z,I64 l,I64 r)
U0 MouseIPSet(I64 x,I64 y,I64 z,I64 l,I64 r)
{
mouse.timestamp=GetTSC;
MouseUpdatePre;
Kernel/Kernel.MAP
+3204 -3213
View File
File diff suppressed because it is too large. Load diff
Kernel/Kernel.PRJ
+32 -29
View File
@@ -1,43 +1,45 @@
//Compile this by calling $LK,"MakeOSPrtBootInstall",A="MN:MakeOSPrtBootInstall"$().
//Don't do it directly. See $LK,"Cmp(\"Kernel\")",A="FF:::/Adam/Boot/InsBoot.CPP,Cmp(\"Kernel\""$.
//Compile this by calling $LK,"MakeOSDrvBootInstall",A="MN:MakeOSDrvBootInstall"$().
//Don't do it directly. See $LK,"Cmp(\"/Kernel/Kernel\")",A="FF:::/Adam/Boot/BootIns.CPP,Cmp(\"/Kernel/Kernel\""$.
#exe {
OptOn(OPTf_WARN_PAREN);
OptOn(OPTf_WARN_DUP_TYPES);
#include "KCfg"
CKernelCfg *kernel_cfg;
kernel_cfg=KernelCfgNew;
Cd(__DIR__);;
OptOn(OPTf_WARN_PAREN);
OptOn(OPTf_WARN_DUP_TYPES);
#include "KCfg"
CKernelCfg *kernel_cfg;
kernel_cfg=KernelCfgNew;
};
#include "Adam1a.HPP"
#include "KernelA.HPP"
#include "KStart"
#include "Utils1a"
#include "Math1a"
#include "/Compiler/CmpDefs.HPP"
#include "Adam1b.HPP"
#include "KUtils"
#include "KMathA"
#include "/Compiler/CompilerA.HPP"
#include "KernelB.HPP"
#include "KExts"
#include "Str1a"
#include "Mem1a"
#include "StrA"
#include "MemA"
#include "KGlbls"
#include "Mem1b"
#include "Math1b"
#include "MemB"
#include "KMathB"
#include "Sched"
#include "Mem1c"
#include "MemC"
#include "Font8x8"
#include "Hash1a"
#include "Str1b"
#include "KHashA"
#include "StrB"
#include "Ints"
#include "DataTypes1a"
#include "KDataTypes"
#include "Compress"
#include "Hash1b"
#include "KHashB"
#include "KLoad"
#include "Date"
#include "StrPrint"
#include "StrScan"
#include "Define1a"
#include "KDefine"
#include "Display"
#include "KeyDev"
#include "Misc1a"
#include "Dbg1a"
#include "KMisc"
#include "KDbg"
#include "Except"
#include "KbdMouse/InputPointer"
#include "KbdMouse/Keyboard"
@@ -45,7 +47,7 @@ kernel_cfg=KernelCfgNew;
#include "KbdMouse/Message"
#include "QSort"
#include "Task1a"
#include "Task"
#include "SrvCmd"
#include "BIOS32"
@@ -53,15 +55,16 @@ kernel_cfg=KernelCfgNew;
#include "DskStr"
#include "DskCache"
#include "DskATA"
#include "Dsk1a"
#include "DskATAId"
#include "DskA"
#include "DskAddDev"
#include "DskDir"
#include "FileSysISO1"
#include "FileSysISO"
#include "FileSysRedSea"
#include "FileSysFAT"
#include "Dsk1b"
#include "DskB"
#include "DskCFile"
#include "Dsk1c"
#include "DskC"
#exe {Cd("..");};
#include "MultiProc"
Kernel/Adam1a.HPP → Kernel/KernelA.HPP
+226 -231
View File
@@ -38,6 +38,7 @@ extern class CIntermediateCode;
#define INVALID_PTR MAX_I64
//(Int to F64 conversion is signed)
//Turn off 80-bit float constants with $LK,"OPTf_NO_BUILTIN_CONST",A="MN:OPTf_NO_BUILTIN_CONST"$.
#define MAX_U64_F64 (0x43F0000000000000(F64))
#define MAX_F64 (0x7FEFFFFFFFFFFFFF(F64))
#define MIN_F64 (0xFFEFFFFFFFFFFFFF(F64))
@@ -207,13 +208,13 @@ public class CMass
CMass *next,*last;
COrder2D3 *state,*DstateDt;
U0 start_saved_area;
U0 start;
U32 flags,num;
F64 mass,drag_profile_factor;
U0 saved_state;
F64 x,y,z,
DxDt,DyDt,DzDt;
U0 end_saved_area;
U0 end;
};
#define SSF_INACTIVE 1
@@ -225,11 +226,11 @@ public class CSpring
CMass *end1,*end2;
F64 f,displacement; //set for you to check
U0 start_saved_area;
U0 start;
U32 flags,num,
end1_num,end2_num;
F64 const,rest_len;
U0 end_saved_area;
U0 end;
};
//Ordinary Differential Equations
@@ -237,11 +238,9 @@ public class CSpring
#define ODEF_PAUSED 2
#define ODEF_STARTED 4
#define ODE_SIGNATURE_VAL 'ODES'
public class CMathODE
{
CMathODE *next,*last;
U32 ode_signature,pad;
I64 flags,n,n_internal;
CMass *next_mass,*last_mass;
CSpring *next_spring,*last_spring;
@@ -344,6 +343,12 @@ class CGDT
CGDTEntry tr_ring3[MP_MAX_PROCESSORS];
};
class CSysLimitBase
{
U16 limit; //Offset of last byte, not size.
U8 *base; //&GDT or &IDT
};
#help_index "Memory/Info"
#define MEM_NUM_E820_ENTRIES 48
#define MEM_E820_ENTRY_SIZE 20
@@ -362,13 +367,13 @@ class CMemE820
#define BIN_SIGNATURE_VAL 'TOSB'
class CBinFile
{//$LK,"Bin File Header Generation",A="FF:::/Compiler/CmpMain.CPP,16 ALIGN"$ by compiler.
{//$LK,"Bin File Header Generation",A="FF:::/Compiler/CMain.CPP,16 ALIGN"$ by compiler.
U16 jmp;
U8 module_align_bits,
reserved;
U32 bin_signature;
I64 module_org,
patch_table_offset, //$LK,"Patch Table Generation",A="FF:::/Compiler/CmpMain.CPP,EIT_ABS_ADDR"$
patch_table_offset, //$LK,"Patch Table Generation",A="FF:::/Compiler/CMain.CPP,EIT_ABS_ADDR"$
file_size;
};
@@ -392,7 +397,7 @@ class CPatchTableAbsAddr
#define EIT_REL_I32 8
#define EIT_IMM_U32 9
#define EIT_REL_I64 10
#define EIT_IMM_U64 11
#define EIT_IMM_I64 11
//reserved
#define EIT_REL32_EXPORT 16
#define EIT_IMM32_EXPORT 17
@@ -410,54 +415,56 @@ class CKernel
{//Must match $LK,"OSStartUp",A="FF:::/Kernel/KStart.CPP,SYS_BOOT_BASE"$
CBinFile h;
U32 jmp,
boot_base,
boot_patch_table_base;
boot_src,
boot_patch_table_base,
sys_run_level;
CDate compile_time;
U32 os_32start,
boot_code;
U0 start;
U32 boot_base;
U16 sys_mem_E801[2];
CMemE820 sys_mem_E820[MEM_NUM_E820_ENTRIES];
CGDT sys_gdt;
U16 sys_gr_mode,
sys_pci_busses;
CSysLimitBase sys_gdt_ptr;
U16 sys_pci_busses;
};
//Run-Levels
#define RLf_16BIT 0
#define RLf_32BIT 1
#define RLf_PATCHED 2
#define RLf_64BIT 3
#define RLf_BOOT_HEAP 4
#define RLf_FULL_HEAP 5
#define RLf_RAW 6
#define RLf_INTERRUPTS 7
#define RLf_MP 8
#define RLf_DSK 9
#define RLf_COMPILER 10
#define RLf_DOC 11
#define RLf_WINMGR 12
#define RLf_LOGIN 13
#define RLf_VGA 1
#define RLf_32BIT 2
#define RLf_PATCHED 3
#define RLf_64BIT 4
#define RLf_BOOT_HEAP 5
#define RLf_FULL_HEAP 6
#define RLf_RAW 7
#define RLf_INTERRUPTS 8
#define RLf_MP 9
#define RLf_DSK 10
#define RLf_COMPILER 11
#define RLf_DOC 12
#define RLf_WINMGR 13
#define RLf_REGISTRY 14
#define RLf_ADAM2 15
#define RLf_HOME 15
#define RLf_ADAM_SERVER 16
#define RLF_16BIT 0x000001
#define RLF_32BIT 0x000002
#define RLF_PATCHED 0x000004
#define RLF_64BIT 0x000008
#define RLF_BOOT_HEAP 0x000010
#define RLF_FULL_HEAP 0x000020
#define RLF_RAW 0x000040
#define RLF_INTERRUPTS 0x000080
#define RLF_MP 0x000100
#define RLF_DSK 0x000200
#define RLF_COMPILER 0x000400
#define RLF_DOC 0x000800
#define RLF_WINMGR 0x001000
#define RLF_LOGIN 0x002000
#define RLF_REGISTRY 0x004000
#define RLF_ADAM2 0x008000
#define RLF_ADAM_SERVER 0x010000
#define RLF_16BIT 0x00001
#define RLF_VGA 0x00002
#define RLF_32BIT 0x00004
#define RLF_PATCHED 0x00008
#define RLF_64BIT 0x00010
#define RLF_BOOT_HEAP 0x00020
#define RLF_FULL_HEAP 0x00040
#define RLF_RAW 0x00080
#define RLF_INTERRUPTS 0x00100
#define RLF_MP 0x00200
#define RLF_DSK 0x00400
#define RLF_COMPILER 0x00800
#define RLF_DOC 0x01000
#define RLF_WINMGR 0x02000
#define RLF_REGISTRY 0x04000
#define RLF_HOME 0x08000
#define RLF_ADAM_SERVER 0x10000
#help_index "Processor"
#define LAPIC_BASE 0xFEE00000
@@ -508,11 +515,10 @@ class CKernel
#define IA32_FS_BASE 0xC0000100
#define IA32_GS_BASE 0xC0000101
//Multi-Processor
class CMPMain
{
class CAP16BitInit
{//AP Multicore
U32 jmp;
I64 sys_temp_ptr;
CSysLimitBase ap_gdt_ptr;
};
#help_index "Time/CPU Cycles;Time/HPET;Time/Jiffies"
@@ -606,7 +612,7 @@ class CSema
#help_index "Hash/System"
//Hash table types
//$LK,"ST_HTT_TYPES",A="FF:::/Kernel/Define1a.CPP,ST_HTT_TYPES"$
//$LK,"ST_HTT_TYPES",A="FF:::/Kernel/KDefine.CPP,ST_HTT_TYPES"$
#define HTt_EXPORT_SYS_SYM 0
#define HTt_IMPORT_SYS_SYM 1
#define HTt_DEFINE_STR 2
@@ -644,8 +650,8 @@ class CSema
#define HTT_CLASS 0x00010 //CHashClass
#define HTT_INTERNAL_TYPE 0x00020 //CHashClass
#define HTT_FUN 0x00040 //CHashFun
#define HTT_WORD 0x00080 //CHashWS -- only in WS table
#define HTT_DICT_WORD 0x00100 //CHashGeneric -- only in WS table
#define HTT_WORD 0x00080 //CHashAC--only in AutoComplete table
#define HTT_DICT_WORD 0x00100 //CHashGeneric--only in AutoComplete table
#define HTT_KEYWORD 0x00200 //CHashGeneric
#define HTT_ASM_KEYWORD 0x00400 //CHashGeneric
#define HTT_OPCODE 0x00800 //CHashOpcode
@@ -684,17 +690,13 @@ public class CHash
//in front for searches. Old function code is not freed
//because a reference might use it.
CHash *next;
//Sometimes, the whole hash table is traversed, for example, in $LK,"PSectFind",A="MN:PSectFind"$().
//To speed traversal, the following links allow skipping
//the empty slots.
CHash *next_added,*last_added;
U8 *str;
U32 type,use_cnt;
//use_cnt is never decremented. It is incremented
//each time a node is found in a hash search.
//One place it is used is to tell if a externed function was unused
//before being defined. It is also used for popularity measures
//in wordstat. You can do a $LK,"Who",A="MN:Who"$() to see
//in autocomplete. You can do a $LK,"Who",A="MN:Who"$() to see
//roughly how many times a symbol has been
//referenced. Beware of instances where
//a hash entry is continuously searched for and
@@ -732,12 +734,11 @@ public class CHashReg:CHash
public class CHashTable
{
CHashTable *next;
CHash *next_added,*last_added;
I64 mask,locked_flags;
CHash **body;
};
public class CHashWS:CHash
public class CHashAC:CHash
{
I32 num;
U32 hits;
@@ -789,7 +790,8 @@ public class CMemberLstMeta
public class CMemberLst
{
CMemberLst *next,*left,*right,*left2,*right2;
CMemberLst *next,*left,*right,
*left2,*right2; //For finding dup class local vars, not names.
U8 *str;
CHashClass *member_class,*member_class2;
CMemberLstMeta *meta;
@@ -820,7 +822,7 @@ public class CHashClass:CHashSrcSym
{//See $LK,"PrsClassNew",A="MN:PrsClassNew"$(). base_class of $LK,"CHashFun",A="MN:CHashFun"$
I64 size,neg_offset;
U32 member_cnt;
U8 ptr_cnt,raw_type;
U8 ptr_stars_cnt,raw_type;
U16 flags;
CMemberLst *member_lst,*member_lst2,
*last_in_member_lst;
@@ -992,20 +994,20 @@ public class CHashGlblVar:CHashSrcSym
#define DOCEF_CHECKED_COLLAPSED 0x40000000000 //Checked or Collapsed
#define DOCEF_CHECK_COLLAPSABLE 0x80000000000
#define DOCEF_REFRESH_DATA 0x100000000000
#define DOCEF_DATA_IS_PTR 0x200000000000
#define DOCEF_HAS_TERMINATOR 0x400000000000
#define DOCEF_ZERO_BASED 0x800000000000
#define DOCEF_HOLD 0x1000000000000
#define DOCEF_TREE 0x2000000000000
#define DOCEF_LST 0x4000000000000
#define DOCEF_SKIP 0x8000000000000
#define DOCEF_POPUP 0x10000000000000
#define DOCEF_SKIP_IN_FORM 0x20000000000000
#define DOCEF_HARD_SKIP 0x40000000000000
#define DOCEF_FILTER_SKIP 0x80000000000000
#define DOCEF_NO_CLICK_ON 0x100000000000000
#define DOCEF_DONT_DRAW 0x200000000000000 //only works on sprites
#define DOCEF_UPDATE_DATA 0x400000000000000
#define DOCEF_UPDATE_DATA 0x200000000000
#define DOCEF_DATA_IS_PTR 0x400000000000
#define DOCEF_HAS_TERMINATOR 0x800000000000
#define DOCEF_ZERO_BASED 0x1000000000000
#define DOCEF_HOLD 0x2000000000000
#define DOCEF_TREE 0x4000000000000
#define DOCEF_LST 0x8000000000000
#define DOCEF_SKIP 0x10000000000000
#define DOCEF_POPUP 0x20000000000000
#define DOCEF_SKIP_IN_FORM 0x40000000000000
#define DOCEF_HARD_SKIP 0x80000000000000
#define DOCEF_FILTER_SKIP 0x100000000000000
#define DOCEF_NO_CLICK_ON 0x200000000000000
#define DOCEF_DONT_DRAW 0x400000000000000 //only works on sprites
#define DOCEG1_DONT_EDIT (DOCEF_DEFINE|DOCEF_HTML_LINK|\
DOCEF_BIN_PTR_LINK|DOCEF_SCROLLING_X|DOCEF_TAG_CB)
@@ -1067,20 +1069,20 @@ public class CHashGlblVar:CHashSrcSym
#define DOCEf_CHECKED_COLLAPSED 42 //Checked or Collapsed
#define DOCEf_CHECK_COLLAPSABLE 43
#define DOCEf_REFRESH_DATA 44
#define DOCEf_DATA_IS_PTR 45
#define DOCEf_HAS_TERMINATOR 46
#define DOCEf_ZERO_BASED 47
#define DOCEf_HOLD 48
#define DOCEf_TREE 49
#define DOCEf_LST 50
#define DOCEf_SKIP 51
#define DOCEf_POPUP 52
#define DOCEf_SKIP_IN_FORM 53
#define DOCEf_HARD_SKIP 54
#define DOCEf_FILTER_SKIP 55
#define DOCEf_NO_CLICK_ON 56
#define DOCEf_DONT_DRAW 57 //only works on sprites
#define DOCEf_UPDATE_DATA 58
#define DOCEf_UPDATE_DATA 45
#define DOCEf_DATA_IS_PTR 46
#define DOCEf_HAS_TERMINATOR 47
#define DOCEf_ZERO_BASED 48
#define DOCEf_HOLD 49
#define DOCEf_TREE 50
#define DOCEf_LST 51
#define DOCEf_SKIP 52
#define DOCEf_POPUP 53
#define DOCEf_SKIP_IN_FORM 54
#define DOCEf_HARD_SKIP 55
#define DOCEf_FILTER_SKIP 56
#define DOCEf_NO_CLICK_ON 57
#define DOCEf_DONT_DRAW 58 //only works on sprites
#define DOCEf_NUM_FLAGS 59
public class CDocBin
@@ -1217,11 +1219,13 @@ class CEdFileName
#define EDF_BAIL 0x100
#define EDF_COLLAPSE 0x200
#define EDF_UNCOLLAPSE 0x400
#define EDF_WAS_WRITE 0x800 //Was exit ESC or SHIFT_ESC?
//Combines with $LK,"Document Flags",A="MN:DOF_MIN_SIZE"$
#define EDf_BAIL 8
#define EDf_COLLAPSE 9
#define EDf_UNCOLLAPSE 10
#define EDf_WAS_WRITE 11
// DOC header flags
#define DOCF_PLAIN_TEXT 0x1
@@ -1334,7 +1338,7 @@ public class CDoc //Linked Text File header
cmd_U8;
U32 doc_signature,cur_bin_num;
I64 max_entries,
refresh_cnt;
updates_cnt;
CEdFindText *find_replace;
U8 *cur_sprite;
@@ -1420,26 +1424,22 @@ class CWinMgrTimingGlbls
I64 last_total_jiffies,
last_idle_pt_hits[MP_MAX_PROCESSORS],
last_swap_cnter[MP_MAX_PROCESSORS];
F64 last_refresh_time,
last_refresh_start_time,
last_refresh_end_time,
refresh_time,
refresh_delta_time;
I64 refresh_cnt,
refresh_skips;
F64 last_calc_idle_time,calc_idle_delta_time;
I64 calc_idle_cnt;
};
#define WMG_FPS 30
public class CWinMgrGlbls
{
I64 updates;
F64 ode_time,
last_ode_time,
desired_fps, //This is chosen by the winmgr.
fps; //You can read but not write this. You have no control.
fps, //You can read but not write this. You have no control.
last_refresh_tS;
CTask *old_focus_task;
CWinMgrTimingGlbls *t;
Bool first, //First after start-up complete
show_menu,
Bool show_menu,
grab_scroll,
grab_scroll_closed;
};
@@ -1477,10 +1477,10 @@ public class CWinMgrGlbls
#define RT_I32 8
#define RT_U32 9
#define RT_I64 10
#define RT_PTR 10
#define RT_PTR 10 //Signed to allow negative err codes. $LK,"DOCM_CANCEL",A="MN:DOCM_CANCEL"$
#define RT_U64 11
#define RT_F32 12 //Not implemented
#define RT_UF32 13 //Not implemented
#define RT_UF32 13 //Not implemented, Fictitious
#define RT_F64 14
#define RT_UF64 15 //Fictitious
#define RT_NUM_IT 16
@@ -1572,7 +1572,7 @@ class CIntermediateCode:CIntermediateCodeBase
//points back to its two earlier addend instructions, not MAlloced,
//just pointers to previous CIntermediate codes in the array.
//Tree links get destroyed during Pass789 when they get overwrites
//Tree links get destroyed during Pass789A when they get overwrites
//by machine code. (Saves room to union the output machine code buffer
//with these links, since they are not needed after pass4.
@@ -1920,6 +1920,13 @@ class CLexCodeCtrl
};
#help_index "Compiler/Lex"
#define __DATE__ #exe{StreamPrint("\"%D\"",Now);}
#define __TIME__ #exe{StreamPrint("\"%T\"",Now);}
#define __LINE__ #exe{StreamPrint("%d",Fs->last_lex->cur_lfn->line_num);}
#define __DEPTH__ #exe{StreamPrint("%d",Fs->last_lex->cur_lfn-&Fs->last_lex->lfns-1);}
#define __FILE__ #exe{StreamPrint("\"%s\"",Fs->last_lex->cur_lfn->full_name);}
#define __DIR__ #exe{StreamDir;}
#define LFSF_DOC 1
#define LFSF_DEFINE 2
class CLexFile
@@ -1927,7 +1934,7 @@ class CLexFile
U8 *buf,
*buf_ptr;
I64 line_num,flags;
U8 *name,
U8 *full_name,
*line_start;
CDoc *doc;
CDocEntry *cur_entry;
@@ -2065,7 +2072,7 @@ public class CLex
U8 *cur_str;
I64 cur_str_len,
class_ip;
U8 *dollar;
U8 *dollar_buf;
I64 dollar_cnt;
U8 *cur_help_index;
I64 last_U16,
@@ -2086,7 +2093,7 @@ public class CLex
I64 pass,
opts,
pass_trace_mask,
otrace_mask,
error_cnt,warning_cnt;
//For intermediate codes with multiple float ops (int<->float conversions)
@@ -2100,7 +2107,7 @@ public class CLex
CAOTCtrl *a;
I64 a_depth;
U0 end_of_zeroed_members;
U0 end_zeroed;
CLexFile lfns[LFN_CNT];
CLexFile stk[LFN_STK_CNT];
U0 pad;#assert !($$&7) //(compiler lags one token)
@@ -2115,15 +2122,11 @@ public class CCmpGlbls
CIntermediateCode ic_nop;
U32 *dual_U16_tokens1,*dual_U16_tokens2,*dual_U16_tokens3,
*binary_ops;
U8 *arg_cnt,*result_cnt,
*ic_bitmap_deref,*ic_bitmap_assign,
*ic_bitmap_not_const,*ic_bitmap_cmp,
*ic_bitmap_fpop;
I64 num_stk_temps,num_reg_vars,num_non_ptr_vars,
stk_temps_mask,reg_vars_mask,non_ptr_vars_mask;
U8 *to_stk_temps_map_odd,*to_stk_temps_map_even,
*to_reg_vars_map,*non_ptr_vars_map;
I64 compiled_lines,compiled_funs,compiled_bytes;
I64 compiled_lines;
};
#help_index "Debugging/Unassemble"
@@ -2153,7 +2156,7 @@ public class CATARep
I64 num,type,base0,base1,unit,irq;
};
//See $LK,"::/Doc/Acknowledgements.TXT"$.
//See $LK,"::/Doc/Credits.TXT"$.
#define ATA_NOP 0x00
#define ATA_DEV_RST 0x08
#define ATA_PACKET 0xA0
@@ -2207,27 +2210,28 @@ class CMBRPrt
end_head;
U16 end_cyl;
U32 offset, //Sects between MBR and first sect
size; //Sects in partition
size; //Sects in drv
};
class CMasterBoot
{
U8 boot_code[440];
U8 code[440];
U32 media_id;
U16 zero;
CMBRPrt p[4];
U16 signature; //AA55
};
class CBootStruct
class CRedSeaBoot
{
U8 jump_and_nop[3],
signature,reserved[4]; //MBR_PT_REDSEA=0x88. Distinguish from real FAT32
I64 sects,
I64 base_offset, //For CD/DVD image copy.
sects,
root_cluster,
bitmap_sects,
unique_id;
U8 code[470];
U8 code[462];
U16 signature2; //0xAA55
};
@@ -2240,7 +2244,7 @@ class CFAT32Boot
U16 reserved_sects;
U8 copies_of_fat;
U16 max_root_dir_entries, //Not used
old_sects_in_prt; //Not used
old_sects_in_drv; //Not used
U8 media_desc; //F64 for hard disk
U16 old_sects_per_fat, //Not used
sects_per_track,
@@ -2270,7 +2274,7 @@ class CFAT32FileInfoSect
U8 unknown[480];
U32 signature2,
free_clusters,
most_recently_allocated;
most_recently_alloced;
U8 reserved[12];
U32 signature3;
};
@@ -2376,7 +2380,7 @@ class CISO1PathEntry
#define ISO1T_BOOT_RECORD 0
#define ISO1T_PRI_VOL_DESC 1
#define ISO1T_SUPPLEMENTARY_DESC 2
#define ISO1T_VOL_PRT_DESC 3
#define ISO1T_VOL_DRV_DESC 3
#define ISO1T_TERMINATOR 255
class CISO1PriDesc
@@ -2554,7 +2558,7 @@ public class CDirEntry
#define BD_SIGNATURE_VAL 'BDSV'
public class CBlkDev
{
CBlkDev *lock_fwding;
CBlkDev *lock_fwding; //If two blkdevs on same controller, use just one lock
I64 locked_flags;
U32 type,flags,
bd_signature;
@@ -2569,21 +2573,21 @@ public class CBlkDev
U32 max_reads,max_writes;
};
//Partition locked flags
#define Plf_LOCKED 0
//Drive locked flags
#define DVlf_LOCKED 0
//See $LK,"ST_PRT_TYPES",A="MN:ST_PRT_TYPES"$
#define PT_NULL 0
#define PT_REDSEA 1 //Supported
#define PT_FAT32 2 //Supported except for short names, to some degree
#define PT_ISO9660 3 //Supported (CD-ROM)
#define PT_ISO13490 4 //Not Supported (CD-ROM)
#define PT_ISO13346 5 //Not Supported (CD-ROM)
#define PT_NTFS 6 //Not Supported
#define PT_UNKNOWN 7
#define PT_NUM_TYPES 8
//See $LK,"ST_DRV_TYPES",A="MN:ST_DRV_TYPES"$
#define DVT_NULL 0
#define DVT_REDSEA 1 //Supported
#define DVT_FAT32 2 //Supported except for short names, to some degree
#define DVT_ISO9660 3 //Supported (CD-ROM)
#define DVT_ISO13490 4 //Not Supported (CD-ROM)
#define DVT_ISO13346 5 //Not Supported (CD-ROM)
#define DVT_NTFS 6 //Not Supported
#define DVT_UNKNOWN 7
#define DVT_NUM_TYPES 8
#define PTf_DISABLE 31 //High bit of type is disable
#define DVTf_DISABLE 31 //High bit of type is disable
#define MBR_PT_FAT12 0x01
#define MBR_PT_FAT32a 0x0B
@@ -2601,33 +2605,31 @@ class CFreeLst
I64 start,size;
};
#define NUM_PRTS 32
#define NUM_DRVS 32
#define PRT_SIGNATURE_VAL 'PTSV'
public class CPrt
#define DRV_SIGNATURE_VAL 'DVSV'
public class CDrv
{
//Don't access ->drv_let directly in case a drive has been remapped.
//Use $LK,"Prt2Drv",A="MN:Prt2Drv"$().
//Use $LK,"Drv2Let",A="MN:Drv2Let"$().
I64 locked_flags;
U32 type, //Bit31 is used as a disable, since it will be unknown
flags, //Flags not used at the moment
pt_signature;
U8 drv_let,text_attr,pad[2];
I64 offset,
dv_signature;
U8 drv_let,text_attr,pad[6];
I64 base_offset,
size,
file_system_info_sect,
map1,map2,
root_cluster,
data,
data_area,
spc; //sectors per cluster
CTask *owning_task;
CBlkDev *bdev;
CBlkDev *bd;
CFAT32FileInfoSect *fis;
I64 num_buffered_map_blks,
I64 map_blk_dirty,
cur_map_blk_num;
U32 *cur_map_blk;
U8 *buffered_map_dirty_bits;
CFreeLst *next_free,*last_free;
};
@@ -2637,7 +2639,7 @@ class CCacheBlk
{
CCacheBlk *next_lru,*last_lru;
CCacheBlk *next_hash,*last_hash;
CPrt *p;
CDrv *dv;
I64 blk;
U8 body[BLK_SIZE];
};
@@ -2649,17 +2651,17 @@ public class CDskGlbls
CCacheBlk *cache_base,*cache_ctrl,**cache_hash_table;
I64 cache_size,read_cnt,write_cnt;
CBlkDev *blkdevs;
CPrt *prts,*drv_to_prt[32];
CDrv *drvs,*let_to_drv[32];
I64 auto_mount_ide_cnt;
U8 first_hd_drv_let,first_cd_drv_let,
temp_filename[136];
U8 temp_filename[136],boot_drv_let,
first_hd_drv_let,first_cd_drv_let;
Bool boot_rescue_drv_pmt,cdrom_boot_is_good;
};
#help_index "File/Internal"
public class CFileAccess
{
CPrt *old_prt,*p;
CDrv *old_dv,*dv;
U8 *old_dir,*mask;
};
@@ -2677,7 +2679,7 @@ public class CFile
{
I64 flags;
CDirEntry de;
CPrt *p;
CDrv *dv;
I64 fblk_num,cluster,file_cluster_num,max_blk;
U8 *cluster_buf;
};
@@ -2686,30 +2688,30 @@ public class CFile
#define _CFG_HEAP_DBG FALSE
#if _CFG_HEAP_DBG
class CMemUnusedAllocated
class CMemUnused
{
CHeapCtrl *hc;
U8 *caller1,*caller2;
CMemUnusedAllocated *next;
CMemUnused *next;
I64 size;
};
class CMemUsedAllocated
class CMemUsed
{
CHeapCtrl *hc;
U8 *caller1,*caller2;
CMemUsedAllocated *next,*last;
CMemUsed *next,*last;
I64 size;
U0 start;
};
#else
class CMemUnusedAllocated
class CMemUnused
{
U0 hc;
U0 caller1,caller2;
CMemUnusedAllocated *next;
CMemUnused *next;
I64 size;
};
class CMemUsedAllocated
class CMemUsed
{
CHeapCtrl *hc;
U0 caller1,caller2;
@@ -2719,7 +2721,7 @@ class CMemUsedAllocated
};
#endif
#help_index "Memory/Blk Pool"
#help_index "Memory/BlkPool"
/*TempleOS does not mess with page tables after it
identity-maps them during boot -- $LK,"SYS_INIT_MEM",A="MN:SYS_INIT_MEM"$.
$LK,"PAGE_SIZE",A="MN:PAGE_SIZE"$ is arbitrary, and is not related to CPU hardware.
@@ -2773,23 +2775,20 @@ class CMemRange
#define SETH_STK (PAGE_SIZE*512)
#define INTERRUPT_STK (PAGE_SIZE*512)
#define DFT_STK (PAGE_SIZE*512)
#define MP_DFT_STK (PAGE_SIZE*512)
#define ADAM_HASH_SIZE (1<<18)
#define STD_HASH_SIZE (1<<12)
#define MP_STD_HASH_SIZE (1<<12)
#define TASK_HASH_SIZE (1<<10)
//locked flags
#define BPlf_LOCKED 0
public class CBlkPool
{
I64 locked_flags,size,allocated_u8s;
I64 locked_flags,alloced_u8s,used_u8s;
CMemBlk *mem_free_lst,*mem_free_2meg_lst,
*free_page_hash[FREE_PAGE_HASH_SIZE],
*free_page_hash2[64-PAGE_BITS];
};
#help_index "Memory/Heap Ctrl"
#help_index "Memory/HeapCtrl"
//locked flags
#define HClf_LOCKED 0
@@ -2798,12 +2797,12 @@ public class CHeapCtrl
{
CBlkPool *bp;
U32 hc_signature,pad;
I64 locked_flags,used_u8s;
I64 locked_flags,alloced_u8s,used_u8s;
CTask *mem_task;
CMemBlk *next_mem_blk,*last_mem_blk;
CMemUnusedAllocated *malloc_free_lst;
CMemUsedAllocated *next_um,*last_um;
CMemUnusedAllocated *heap_hash[HEAP_HASH_SIZE/sizeof(U8 *)];
CMemUnused *malloc_free_lst;
CMemUsed *next_um,*last_um;
CMemUnused *heap_hash[HEAP_HASH_SIZE/sizeof(U8 *)];
};
#help_index "Devices"
@@ -2885,7 +2884,7 @@ public U32i class CBGR
U8 b,g,r,reserved;
};
#help_index "Keyboard Devices"
#help_index "Keyboard Devices;Char/Input"
#define KBD_PORT 0x60
#define KBD_CTRL 0x64
public class CKbdStateGlbls
@@ -3024,7 +3023,6 @@ public class CCtrl
};
#help_index "Menus"
#define MENU_SIGNATURE_VAL 'MnuS'
public class CMenuEntry
{
CMenuEntry *next;
@@ -3040,8 +3038,7 @@ public class CMenu
CMenuEntry *sub;
CTask *task;
I64 flags;
U32 mu_signature;
U8 attr,checked_attr,pad[2];
U8 attr,pad[7];
};
#help_index "Task"
@@ -3064,7 +3061,7 @@ class CFPU
U8 body[512];
};
#help_index "Task/Srv"
#help_index "Task/Srv/Exe"
#define SVCf_WAKE_MASTER 0
#define SVCf_FOCUS_MASTER 1
#define SVCf_EXIT_ON_COMPLETE 2
@@ -3076,12 +3073,12 @@ class CFPU
#define SVCf_FREE_ON_COMPLETE 7
#define SVCf_ADD_TO_QUE 8
#define SVCT_TEXT_INPUT 0
#define SVCT_MSG 1
#define SVCT_EXE_STR 2
#define SVCT_TEXT_INPUT 0 //$LK,"TaskText",A="MN:TaskText"$() Feed StdIn
#define SVCT_MSG 1 //$LK,"TaskMsg",A="MN:TaskMsg"$() Post msg
#define SVCT_EXE_STR 2 //$LK,"TaskExe",A="MN:TaskExe"$() Compile & execute src code text
//MP cmds
#define SVCT_CALL 3
#define SVCT_SPAWN_TASK 4
#define SVCT_CALL 3 //$LK,"JobQue",A="MN:JobQue"$() Tell MP to call function
#define SVCT_SPAWN_TASK 4 //$LK,"Spawn",A="MN:Spawn"$() Tell MP to spawn task
class CSrvCmd
{
@@ -3145,6 +3142,7 @@ class CSrvCtrl
public class CTaskSettings
{
CTaskSettings *next;
U8 *cur_dir;
I64 left,right,top,bottom;
U0 (*draw_it)(CTask *task,CDC *dc);
U0 (*task_end_cb)();
@@ -3155,15 +3153,15 @@ public class CTaskSettings
U8 text_attr,title_src,
border_attr,border_src,
task_title[TASK_TITLE_LEN+1];
Bool border,preempt,cursor,scroll,wordstat,pad[3];
Bool border,preempt,cursor,scroll,autocomplete,pad[3];
U0 pad;#assert !($$&7) //(compiler lags one token)
};
#help_index "Task"
//Border ATTR src
#define BDS_CONST 0
#define BDS_CUR_PRT 1
#define BDS_ED_FILENAME_PRT 2
#define BDS_CUR_DRV 1
#define BDS_ED_FILENAME_DRV 2
//Task title src
#define TTS_CONST 0
@@ -3187,6 +3185,7 @@ U0 pad;#assert !($$&7) //(compiler lags one token)
#define TASKf_PENDING_BREAK 11
#define TASKf_BREAK_TO_SHIFT_ESC 12
#define TASKf_KILL_AFTER_DBG 13
#define TASKf_NONTIMER_RAND 14
//locked flags
#define TASKLf_TASK_LOCK 0
@@ -3210,7 +3209,7 @@ class CTaskStk
U0 stk_base;
};
public class CTask //The Fs segment reg points to current CTask
public class CTask //The Fs segment reg points to current CTask.
{
CTask *addr; //Self-addressed ptr
U32 task_signature,task_in_que_signature;
@@ -3224,7 +3223,7 @@ public class CTask //The Fs segment reg points to current CTask
*border_doc;
I64 win_left,win_right,win_top,win_bottom;
CPrt *cur_prt;
CDrv *cur_dv;
U8 *cur_dir;
CTask *parent_task,
@@ -3288,7 +3287,7 @@ public class CTask //The Fs segment reg points to current CTask
U0 (*task_end_cb)();
CTask *song_task,*animate_task;
I64 rnd_seed,
I64 rand_seed,
task_num,
fault_num,fault_err_code;
CTask *popup_task;
@@ -3335,7 +3334,7 @@ class CTSS
#define CPUf_RAN_A_TASK 0
#define CPUf_SETH_SLEEP 1
public class CCPU //The Gs segment reg points to current CCPU
public class CCPU //The Gs segment reg points to current CCPU.
{
CCPU *addr; //Self-addressed ptr
I64 num,cpu_flags,
@@ -3357,8 +3356,9 @@ U0 pad;#assert !($$&7) //(compiler lags one token)
};
#help_index "Memory/Page Tables"
#define MEM_MAPPED_SPACE 0x2000000000 //Arbitrarily set to 128 Gig
#define MEM_NUM_PML1 1 //First 2 Meg are 4K resolution
#define MEM_MIN_MEG 512 //512 Meg minimum.
#define MEM_MAPPED_SPACE 0x2000000000 //Arbitrarily set to 128 Gig.
#define MEM_NUM_PML1 1 //First 2 Meg are 4K resolution.
#define MEM_NUM_PML2 (MEM_MAPPED_SPACE>>(9+21))
#define MEM_NUM_PML3 1
#define MEM_NUM_PML4 1
@@ -3498,7 +3498,7 @@ public class CTextGlbls
I64 raw_col,raw_flags;
U8 *raw_screen_image;
I64 rows,cols; //Use TEXT_ROWS,TEXT_COLS
U8 *font;
U64 *font;
};
#define FONT_WIDTH 8
@@ -3546,11 +3546,11 @@ class CGrSym
public class CDC
{
U0 start_saved_area;
I32 width,width_internal,height,
U0 start;
I32 width,width_internal,
height,
flags;
I64 body_size;
U0 end_saved_area;
U0 end;
//public (Change directly)
CColorROPU32 color,
@@ -3608,41 +3608,35 @@ U0 pad;#assert !($$&7) //(compiler lags one token)
};
#help_index "Devices"
#define VGA_GRAPHIC_MEM_BASE 0xA0000
#define VGA_TEXT_MEM_BASE 0xB8000
//VGA Memory
#define VGAM_GRAPHICS 0xA0000
#define VGAM_TEXT 0xB8000
#define VGA_ATTR_INDEX 0x03C0
#define VGA_ATTR_DATA_WRITE 0x03C0 //alias
#define VGA_ATTR_DATA_READ 0x03C1
#define VGA_MISC_OUTPUT 0x03C2
#define VGA_SC_INDEX 0x03C4
#define VGA_SC_DATA 0x03C5
#define VGA_PALETTE_MASK 0x03C6
#define VGA_REG_READ 0x03C7
#define VGA_REG_WRITE 0x03C8
#define VGA_PALETTE_DATA 0x03C9
#define VGA_CRTC_INDEX 0x03D4
#define VGA_CRTC_DATA 0x03D5
#define VGA_INPUT_STAT 0x03DA
#define VGA_MAP_MASK 0x02
//VGA I/O ports
#define VGAP_ATTR_INDEX 0x03C0
#define VGAP_ATTR_DATA_WRITE 0x03C0 //alias
#define VGAP_ATTR_DATA_READ 0x03C1
#define VGAP_MISC_OUTPUT 0x03C2
#define VGAP_INDEX 0x03C4
#define VGAP_DATA 0x03C5
#define VGAP_PALETTE_MASK 0x03C6
#define VGAP_REG_READ 0x03C7
#define VGAP_REG_WRITE 0x03C8
#define VGAP_PALETTE_DATA 0x03C9
#define VGAP_CRTC_INDEX 0x03D4
#define VGAP_CRTC_DATA 0x03D5
#define VGAP_INPUT_STAT 0x03DA
#define VGA_H_TOTAL 0x00
#define VGA_H_BLANK_START 0x02
#define VGA_H_RETRACE_START 0x04
#define VGA_V_TOTAL 0x06
#define VGA_MAX_SCAN_LINE 0x09
#define VGA_V_RETRACE_END 0x11
#define VGA_OFFSET 0x13
#define VGA_V_BLANK_START 0x15
#define VGA_MODE_CTRL 0x17
//VGA Registers
#define VGAR_MAP_MASK 0x02
#help_index "Compression/Piece by Piece"
#define ARC_MAX_BITS 12
#define ARC_MAX_ENTRY (1<<ARC_MAX_BITS-1)
#define CT_NONE 0
#define CT_7_BIT 1
#define CT_8_BIT 2
#define CT_NONE 1
#define CT_7_BIT 2
#define CT_8_BIT 3
class CArcEntry
{
CArcEntry *next;
@@ -3673,7 +3667,7 @@ public class CArcCtrl
public class CArcCompress
{
I64 compressed_size,expanded_size;
U16 compression_type,flags;
U8 compression_type;
U0 body;
};
@@ -3780,12 +3774,13 @@ public class CDbgGlbls
#define BOOT_RAM_LIMIT 0x97000
#define BOOT_STK_SIZE BLK_SIZE
#define BOOT_CODE_RAM 1
#define BOOT_CODE_HARDDRV 2
#define BOOT_CODE_CDROM 3
#define BOOT_SRC_NULL 0
#define BOOT_SRC_RAM 1
#define BOOT_SRC_HARDDRV 2
#define BOOT_SRC_CDROM 3
// $LK,"Auto",A="MN:Auto"$("") StdIn for call to $LK,"MakeOSPrtBootInstall",A="MN:MakeOSPrtBootInstall"$().
#define STD_DISTRO_CDROM_CFG "Tb1\nScale2Mem(2048,0x40000)\nt3 \n\n\n\n\n"
// $LK,"Auto",A="MN:Auto"$("") StdIn for call to $LK,"MakeOSDrvBootInstall",A="MN:MakeOSDrvBootInstall"$().
#define STD_DISTRO_CDROM_CFG "Tb1\nScale2Mem(2048,0x40000)\nt3 \n\n\n\n"
#help_index "Misc/Accts"
//Acct Registry sys_msg_flags. $LK,"AcctOneTimePopUp",A="MN:AcctOneTimePopUp"$()
Kernel/Adam1b.HPP → Kernel/KernelB.HPP
+17 -18
View File
@@ -1,7 +1,7 @@
/* Kernel ASM symbols.
$LK,"Adam1b",A="FF:::/Kernel/Kernel.PRJ,Adam1b"$ Kernel.PRJ
$LK,"Adam1b",A="FF:::/Compiler/Compiler.PRJ,Adam1b"$ Compiler.PRJ
$LK,"Adam1b",A="FF:::/Kernel/Adam1.CPP,Adam1b"$ Adam1.CPP
$LK,"KernelB",A="FF:::/Kernel/Kernel.PRJ,KernelB"$ Kernel.PRJ
$LK,"KernelB",A="FF:::/Compiler/Compiler.PRJ,KernelB"$ Compiler.PRJ
$LK,"KernelB",A="FF:::/Adam.CPP,KernelB"$ Adam.CPP
*/
#help_index "Bit"
@@ -22,8 +22,8 @@ public _extern _LBEQU Bool LBEqu(U8 *bit_field,I64 bit,Bool val); //Locked Set b
#help_index "Boot"
_extern SYS_BOOT_BASE U32 sys_boot_base;
_extern SYS_BOOT_CODE U32 sys_boot_code;
_extern SYS_BOOT_PATCH_TABLE_BASE U32 sys_boot_patch_table_base;
_extern SYS_BOOT_SRC U32 sys_boot_src;
_extern SYS_RUN_LEVEL U32 sys_run_level;
#help_index "Call"
@@ -50,9 +50,6 @@ public _intern IC_QUE_INS_REV U0 QueInsRev(CQue *entry,CQue *succ);//Reversed in
//Ins item into que before successor.
public _intern IC_QUE_REM U0 QueRem(CQue *entry); //Remove Item from queue.
#help_index "Graphics/Screen"
public _extern SYS_BIOS_GR_MODE U16 sys_bios_gr_mode; //INT 0x10 mode number.
#help_index "I/O;Processor/IO Port"
public _intern IC_IN_U16 I64 InU16(I64 port); //Read U16 from I/O port.
public _intern IC_IN_U32 I64 InU32(I64 port); //Read U32 from I/O port.
@@ -93,8 +90,8 @@ public _intern IC_TO_F64 F64 ToF64(I64 i); //Convert to F64.
public _intern IC_TO_I64 I64 ToI64(F64 d); //Convert to I64. Truncates.
public _extern _ARG F64 Arg(F64 x,F64 y); //Polar coordinate angle.
public _extern _CEIL F64 Ceil(F64 d); //Ceiling of F64.
public _extern _CLAMP_I64 I64 ClampI64(I64 p,I64 lo,I64 hi); //Clamp to I64 [] range.
public _extern _CLAMP_U64 U64 ClampU64(U64 p,U64 lo,U64 hi); //Clamp to U64 [] range.
public _extern _CLAMP_I64 I64 ClampI64(I64 dv,I64 lo,I64 hi); //Clamp to I64 [] range.
public _extern _CLAMP_U64 U64 ClampU64(U64 dv,U64 lo,U64 hi); //Clamp to U64 [] range.
public _extern _EXP F64 Exp(F64 d); //Exponential function.
_extern _FCLEX U0 Fclex();
_extern _FLDCW U0 Fldcw(U16 w);
@@ -129,8 +126,8 @@ public _extern _D3_MUL_EQU CD3 *D3MulEqu(CD3 *prod,F64 s); //prod *= s
public _extern _D3_NORM F64 D3Norm(CD3 *d); //Norm d
public _extern _D3_NORM_SQR F64 D3NormSqr(CD3 *d); //Norm Squared d
public _extern _D3_SUB CD3 *D3Sub(CD3 *d1,CD3 *d2,CD3 *diff); //d1-d2 -->diff
public _extern _D3_SUB_EQU CD3 *D3SubEqu(CD3 *diff,CD3 *d); //diff-=d
public _extern _D3_UNIT CD3 *D3Unit(CD3 *d); //Convert to unit vect
public _extern _D3_SUB_EQU CD3 *D3SubEqu(CD3 *diff,CD3 *d); //diff-=d
public _extern _D3_ZERO CD3 *D3Zero(CD3 *dst); //Convert to zero
#help_index "Memory"
@@ -146,12 +143,12 @@ _extern SYS_HEAP_INIT_FLAG U8 sys_heap_init_flag;
_extern SYS_HEAP_INIT_VAL U8 sys_heap_init_val;
_extern SYS_MEM_INIT_FLAG U8 sys_mem_init_flag;
_extern SYS_MEM_INIT_VAL U8 sys_mem_init_val;
_extern SYS_VAR_INIT_FLAG U8 sys_var_init_flag;
_extern SYS_VAR_INIT_VAL U8 sys_var_init_val;
_extern SYS_VAR_INIT_FLAG U8 sys_var_init_flag;
#help_index "Memory/Blk Pool"
public _extern SYS_CODE_BP CBlkPool *sys_code_bp; //System's blk pool for code.
public _extern SYS_DATA_BP CBlkPool *sys_data_bp; //System's blk pool for data.
#help_index "Memory/BlkPool"
public _extern SYS_CODE_BP CBlkPool *sys_code_bp; //System's BlkPool for code.
public _extern SYS_DATA_BP CBlkPool *sys_data_bp; //System's BlkPool for data.
#help_index "Memory/Info"
_extern SYS_HEAP_BASE U8 *sys_heap_base;
@@ -181,9 +178,9 @@ public _extern SYS_FOCUS_TASK CTask *sys_focus_task; //Current focus task.
#help_index "MultiCore"
#help_file "::/Doc/MultiCore"
public _extern SYS_CPU_STRUCTS CCPU *cpu_structs;//$LK,"Gs",A="MN:Gs"$ points to cur $LK,"CCPU",A="MN:CCPU"$.
public _extern SYS_CPU_STRUCTS CCPU *cpu_structs; //$LK,"Gs",A="MN:Gs"$ points to cur $LK,"CCPU",A="MN:CCPU"$.
public _extern SYS_MP_CNT I64 mp_cnt; //Count of cores
_extern SYS_MP_CNT_INITIAL I64 mp_cnt_initial; //only used during $LK,"MPStart",A="MN:MPStart"$
_extern SYS_MP_CNT_INITIAL I64 mp_cnt_initial; //only used during $LK,"BSPStartMP",A="MN:BSPStartMP"$
_extern SYS_MP_CNT_LOCK I64 mp_cnt_lock;
_extern SYS_SEMAS CSema sys_semas[NUM_SYS_SEMAS];
@@ -220,8 +217,10 @@ public _extern SYS_CACHE_LINE_WIDTH I64 sys_cache_line_width; //CPU's Cache line
_extern SYS_GDT CGDT sys_gdt;
#help_index "Processor/Cache;Memory/Cache"
public _intern IC_CLFLUSH U0 CLFlush(U8 *a); //Flush cache line.
public _intern IC_INVLPG U0 InvlPg(U8 *a); //Invalidate page at addr.
public _intern IC_CLFLUSH U0 CLFlush(U8 *a); //Flush cache line instruction.
#help_index "Processor/Page Tables;Memory/Page Tables"
public _intern IC_INVLPG U0 InvlPg(U8 *a); //Invalidate page at addr instruction.
#help_index "Task"
public _intern IC_PREEMPT Bool Preempt(Bool val); //Turn mutli-tasking preemption OFF/ON.
Kernel/Adam1c.HPP → Kernel/KernelC.HPP
+89 -97
View File
@@ -96,28 +96,28 @@ public extern U0 PutChars(U64 ch);
extern U0 PutHex(I64 num,I64 width);
public extern U0 PutKey(I64 ch=0,I64 sc=0);
extern U0 PutS(U8 *st); //Use $LK,"Print",A="MN:Print"$()
public extern Bool Silent(Bool val);
public extern Bool Silent(Bool val=ON);
extern U8 *StrPrintHex(U8 *dst,I64 num;I64 width);
#help_index "Char;Debugging/Raw Output"
public extern CTextGlbls text;
#help_index "Compiler/Lex"
public extern U0 SetSrcFileInfo(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0);
public extern U0 HashSrcFileSet(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0);
#help_index "Compiler;Cmd Line (Typically)"
extern U8 *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR); //INVALID_PTR means don't care what load addr.
#help_index "Compression"
public extern CArcCompress *CompressBuf(U8 *src,I64 size,I64 flags=0,CTask *mem_task=NULL);
public extern CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL);
public extern U8 *ExpandBuf(CArcCompress *r,CTask *mem_task=NULL);
#help_index "Compression/Piece by Piece"
public extern U0 ArcCompressBuf(CArcCtrl *c);
public extern U0 ArcCtrlDel(CArcCtrl *c);
public extern CArcCtrl *ArcCtrlNew(Bool expand,Bool seven_bit);
public extern CArcCtrl *ArcCtrlNew(Bool expand,I64 compression_type=CT_8_BIT);
public extern U0 ArcExpandBuf(CArcCtrl *c);
public extern U0 ArcFinishCompression(CArcCtrl *c);
public extern Bool ArcFinishCompression(CArcCtrl *c);
#help_index "Data Types/Circular Queue"
public extern I64 QueCnt(CQue *root);
@@ -172,7 +172,7 @@ public extern I64 B2(CTask *task=NULL,Bool live=TRUE);
extern CBpt *BptFind(U8 *needle_addr,CTask *haystack_task=NULL,Bool rem=FALSE);
public extern Bool BptR(U8 *addr,CTask *task=NULL,Bool live=TRUE,Bool rem=TRUE);
public extern Bool BptS(U8 *addr,CTask *task=NULL,Bool live=TRUE);
public extern U0 E(U8 *addr,I64 cnt=512,I64 edf_dof_flags=0);
public extern Bool E(U8 *addr,I64 cnt=512,I64 edf_dof_flags=0);
public extern U0 G(U8 *ip=INVALID_PTR,CTask *task=NULL);
public extern U0 G2(U8 *ip=INVALID_PTR,CTask *task=NULL);
public extern Bool InDbg(Bool val);
@@ -180,7 +180,7 @@ public extern Bool IsDbg();
public extern U0 S(U8 *ip=INVALID_PTR,CTask *task=NULL);
#help_index "Debugging/Debugger;DolDoc/Cmd Line (Typically);Cmd Line (Typically);Training"
public extern U0 Man(U8 *st);
public extern Bool Man(U8 *st,I64 edf_dof_flags=0);
#help_index "Debugging/Dump"
public extern U0 CallerRep(U8 **rbp=NULL,CTask *task=NULL);
@@ -213,10 +213,10 @@ public extern U0 VGAFlush();
#help_index "Debugging;Debugging/Debugger"
public extern U0 Dbg(U8 *msg=NULL,I64 msg_num=0);
public extern U0 EdLite(U8 *filename,I64 num=1);
extern U0 EdLiteFileLine(U8 *fl_file_line);
public extern U0 Fix();
public extern U0 SetFix(U8 *filename,I64 line);
public extern Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0);
extern Bool EdLiteFileLine(U8 *fl_file_line,I64 edf_dof_flags=0);
public extern Bool Fix(I64 edf_dof_flags=0);
public extern U0 FixSet(U8 *filename,I64 line);
#help_index "Define;Char/Define"
#help_file "::/Doc/Define"
@@ -264,12 +264,12 @@ public extern I64 FSize(CFile *f);
public extern Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1);
#help_index "File/Cmd Line (Typically);Cmd Line (Typically)"
public extern Bool Cd(U8 *dirname,Bool make_dirs=FALSE);
public extern Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE);
public extern U0 ChgDsk(U8 drv_let=0);
public extern I64 Del(U8 *wild,Bool print_msg=TRUE);
public extern I64 Dir(U8 *wild="*",Bool full=FALSE);
public extern Bool Drv(U8 drv_let);
public extern Bool MapDrv(U8 drv_let,CPrt *p);
public extern Bool MapDrv(U8 drv_let,CDrv *dv);
public extern Bool MkDir(U8 *filename);
#help_index "File/FileNames"
@@ -292,52 +292,50 @@ public extern U0 PutDirLink(U8 *dirname);
public extern U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE);
public extern U0 ToFileLine(U8 *_fl_file_line,U8 **_filename,I64 *_linenum);
public extern U8 *ToggleZorNotZ(U8 *name);
public extern U8 *sys_acct;
#help_index "File/FileNames;Misc"
public extern U8 *FileNameTempTxt();
#help_index "File/Internal"
public extern Bool DirNew(CPrt *p,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE);
public extern Bool DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE);
public extern U0 FileAccessDel(CFileAccess *fa);
public extern CFileAccess *FileAccessNew(U8 *mask,Bool make_mask=FALSE,Bool make_dirs=FALSE,Bool no_mask=FALSE);
extern I64 FileAttr(U8 *name,I64 old_attr=0);
#help_index "File/Low Level"
public extern U0 BlkDevChk(CBlkDev *bdev);
public extern Bool BlkDevLock(CBlkDev *bdev);
public extern U0 BlkDevChk(CBlkDev *bd);
public extern Bool BlkDevLock(CBlkDev *bd);
public extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
public extern Bool BlkDevUnlock(CBlkDev *bdev,Bool rst=FALSE);
public extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
public extern U0 BlkDevsRelease();
extern U0 CleanMAPBuf(CPrt *p);
public extern I64 Cluster2Blk(CPrt *p,I64 c);
public extern I64 ClusterNumNext(CPrt *p,I64 c,I64 cnt=1);
public extern I64 ClustersAlloc(CPrt *p,I64 c=0,I64 cnt=1,Bool contiguous=FALSE);
public extern I64 Cluster2Blk(CDrv *dv,I64 c);
public extern I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1);
public extern I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE);
extern Bool CopySingle(U8 *f1,U8 *f2); //Just one file
public extern CBlkDev *Drv2BlkDev(U8 drv_let=0);
public extern CPrt *Drv2Prt(U8 drv_let=0);
public extern U8 Drv2Let(CDrv *dv=NULL);
public extern U0 DrvChk(CDrv *dv);
public extern Bool DrvLock(CDrv *dv);
public extern CDrv *DrvMakeFree(U8 drv_let);
public extern U8 *DrvModelNum(U8 drv_let=0);
public extern CDrv *DrvNextFree(U8 first_drv_let='C');
public extern U8 *DrvSerialNum(U8 drv_let=0);
extern U0 FAT32FreeClusters(CPrt *p,I64 c);
extern I64 Name2DirCluster(CPrt *p,U8 *dirname);
extern I64 Name2ParentDirCluster(CPrt *p,U8 *dirname);
public extern U8 Prt2Drv(CPrt *p=NULL);
public extern U0 PrtChk(CPrt *p);
public extern Bool PrtLock(CPrt *p);
public extern CPrt *PrtMakeFree(U8 drv_let);
public extern CPrt *PrtNextFree(U8 first_drv_let='C');
public extern Bool PrtUnlock(CPrt *p,Bool rst=FALSE);
public extern U0 PrtsRelease();
public extern Bool RBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt);
public extern I64 RClusters(CPrt *p,U8 *buf,I64 c,I64 cnt);
public extern I64 RClustersBlks(CPrt *p,U8 *buf,I64 c,I64 blks);
extern U0 RedSeaFSFreeClusters(CPrt *p,I64 c,I64 cnt);
public extern Bool DrvUnlock(CDrv *dv,Bool rst=FALSE);
public extern U0 DrvsRelease();
extern U0 FAT32FreeClusters(CDrv *dv,I64 c);
public extern CBlkDev *Let2BlkDev(U8 drv_let=0);
public extern CDrv *Let2Drv(U8 drv_let=0);
extern I64 Name2DirCluster(CDrv *dv,U8 *dirname);
extern I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname);
public extern Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
public extern I64 RClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt);
public extern I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks);
extern U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt);
extern I64 SysDel(U8 *wild,Bool make_mask); //this is dangerous
extern CDirEntry *SysFilesFind(U8 *files_find_mask,I64 fuf_flags);
public extern Bool WBlks(CPrt *p,U8 *buf, I64 blk, I64 cnt);
public extern I64 WClusters(CPrt *p,U8 *buf,I64 c,I64 cnt);
public extern I64 WClustersBlks(CPrt *p,U8 *buf,I64 c,I64 blks);
public extern U0 WZeroBlks(CPrt *p,I64 blk,I64 cnt);
public extern Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
public extern I64 WClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt);
public extern I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks);
public extern U0 WZeroBlks(CDrv *dv,I64 blk,I64 cnt);
#help_index "File/Program Routines"
public extern U0 DirEntryDel(CDirEntry *tempde);
@@ -345,24 +343,23 @@ public extern U0 DirEntryDel2(CDirEntry *tempde);
public extern U0 DirTreeDel(CDirEntry *tempde);
public extern U0 DirTreeDel2(CDirEntry *tempde);
public extern Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0);
public extern U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL,Bool raw=FALSE);
public extern I64 FileWrite(U8 *filename,U8 *fbuf,
I64 size,CDate cdt=0,I64 attr=0,Bool raw=FALSE);
public extern U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL);
public extern I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0);
#help_index "File/Program Routines;File/FileNames"
public extern CDirEntry *FilesFind(U8 *files_find_mask,I64 fuf_flags=0);
#help_index "File/System"
public extern CATARep *ATAIDDrvs(CATARep *root,U8 _sys_acct_drv,CATARep **_ata_drv,CATARep **_atapi_drv);
public extern CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv);
extern CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit);
extern Bool ATAPIStartStop(CBlkDev *bdev,F64 timeout,Bool start);
extern Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start);
extern I64 ATAProbe(I64 base0,I64 base1,I64 unit);
extern U0 ATAReadBlks(CBlkDev *bdev,U8 *buf, I64 blk, I64 cnt);
extern U0 ATAWriteBlks(CBlkDev *bdev,U8 *buf, I64 blk, I64 cnt);
extern U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt);
extern U0 ATAWriteBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt);
public extern I64 AutoMountIDE();
extern I64 BlkDevAdd(CBlkDev *bdev,Bool one_prt,Bool make_free);
extern I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free);
extern U0 DskCacheInit(I64 size_in_U8s);
public extern U0 DskCacheInvalidate(CPrt *p);
public extern U0 DskCacheInvalidate(CDrv *dv);
public extern CDskGlbls dsk;
#help_index "Graphics/Color"
@@ -390,14 +387,14 @@ public _extern _HASH_STR I64 HashStr(U8 *st);
public extern U0 HashTableDel(CHashTable *table);
public extern CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL);
public extern I64 HashTablePurge(CHashTable *table);
public extern I64 HashVal(CHash *temph);
public extern I64 HashTypeNum(CHash *temph);
public extern I64 HashVal(CHash *temph);
extern U0 SysSymImportsResolve(U8 *sptr,I64 ld_flags=0);
#help_index "Hash/Frame"
#help_file "::/Doc/Frame"
public extern I64 FramePtr(U8 *name,CTask *task=NULL);
public extern CHashGeneric *FramePtrAdd(U8 *name,I64 val,CTask *task=NULL);
public extern CHashGeneric *FramePtrAdd(U8 *name,I64 val=0,CTask *task=NULL);
public extern I64 FramePtrDel(U8 *name,CTask *task=NULL);
public extern I64 FramePtrSet(U8 *name,I64 val,CTask *task=NULL);
@@ -408,12 +405,12 @@ public extern I64 HashLstAdd(U8 *lst,I64 type,CHashTable *table);
public extern I64 HashDefineLstAdd(U8 *name,I64 type,CHashTable *table);
#help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically);Install"
public extern U0 PrtRep();
public extern U0 DrvRep();
#help_index "Input Pointer"
#help_file "::/Doc/InputPointer"
public extern U0 GridInit();
public extern U0 SetIP(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64);
public extern U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64);
public extern CIPStateGlbls ip;
public extern CGridGlbls ip_grid;
extern CIPStateGlbls ip_last;
@@ -432,18 +429,18 @@ extern CATARep *ATARepFind(CATARep *haystack_root,I64 needle_num);
public extern Bool DrvEnable(U8 drv_let,Bool val);
#help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically);"
public extern U0 Fmt(U8 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=PT_FAT32);
public extern U0 Fmt(U8 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32);
public extern U0 Mount(Bool repartition=FALSE);
#help_index "Install;Memory/Blk Pool"
#help_index "Install;Memory/BlkPool"
public extern I64 Scale2Mem(I64 min,I64 max,I64 limit=2*1024*1024*1024);
#help_index "Keyboard Devices/System;Char/System"
#help_file "::/Doc/KeyDev"
public extern U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE);
public extern U0 KeyDescSet(U8 *fmt,...);
public extern CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE);
public extern U0 KeyDevRem(CKeyDevEntry *tempp);
public extern U0 SetCtrlAltLetCB(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE);
public extern U0 SetKeyDesc(U8 *fmt,...);
extern CKeyDevGlbls keydev;
extern CSrvCmd sys_macro_root;
extern CTask *sys_macro_util_task;
@@ -460,13 +457,13 @@ public extern I64 KbdMouseEvtTime();
extern U0 KbdMouseHandler(Bool poll_kbd,Bool poll_mouse);
extern U0 KbdMouseVarsInit();
extern I64 KbdMsgsQue();
public extern U0 KbdTypeMatic(U8 delay);
extern Bool MouseDriverInstall();
public extern I64 PressAKey();
public extern I64 ScanChar();
public extern Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE);
public extern U0 SetTypeMatic(U8 delay);
public extern Bool YorN();
public extern CKbdStateGlbls kbd;
public extern Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE);
#help_index "Math"
public extern I64 CeilI64(I64 num,I64 to);
@@ -478,42 +475,29 @@ public extern F64 Max(F64 n1,F64 n2);
public extern F64 Min(F64 n1,F64 n2);
public extern F64 Pow10I64(I64 i);
public extern F64 Rand(); //With timestamp
public extern F64 Rand2(); //Without timestamp
public extern I16 Rand2I16();
public extern I32 Rand2I32();
public extern I64 Rand2I64();
public extern U16 Rand2U16();
public extern U32 Rand2U32();
public extern U64 Rand2U64();
public extern I16 RandI16();
public extern I32 RandI32();
public extern I64 RandI64();
public extern U16 RandU16();
public extern U32 RandU32();
public extern U64 RandU64();
public extern U0 Randomize(I64 seed=0);
public extern I64 RoundI64(I64 num,I64 to);
extern I64 sys_rnd_seed;
public extern I64 Seed(I64 seed=0,CTask *task=NULL);
#help_index "Memory/Adam Heap"
public extern U8 *ACAlloc(I64 size);
public extern U8 *AMAlloc(I64 size);
public extern U8 *AMAllocIdentical(U8 *src);
#help_index "Memory/Blk Pool"
#help_index "Memory/BlkPool"
public extern U0 BlkPoolAdd(CBlkPool *bp,CMemBlk *m,I64 pages512);
public extern U0 BlkPoolInit(CBlkPool *bp,I64 pages512);
public extern U8 *MemBlks2MegAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
public extern U0 MemBlks2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL);
public extern U8 *MemBlksIndependentAlloc(I64 *_pages512,CBlkPool *bp=NULL);
public extern U0 MemBlksNonTaskFree(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL);
public extern U8 *MemBlksUncachedAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
public extern U8 *MemBlksWriteThroughAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
#help_index "Memory/Heap Ctrl"
public extern CHeapCtrl *HeapCtrlBPInit(CBlkPool *bp,I64 pages512);
public extern U0 HeapCtrlDel(CHeapCtrl *hc);
public extern CHeapCtrl *HeapCtrlInit(CHeapCtrl *hc=NULL,CTask *task=NULL,CBlkPool *bp);
public extern U8 *Mem2MegAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
public extern U0 Mem2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL);
public extern U8 *Mem2MegUncachedAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
public extern U8 *Mem2MegWriteThruAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL);
public extern U8 *Mem512Alloc(I64 *_pages512,CBlkPool *bp=NULL);
public extern U0 Mem512Free(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL);
#help_index "Memory/Heap"
public extern U8 *CAlloc(I64 size,CTask *mem_task=NULL);
@@ -526,6 +510,11 @@ public _extern _MHEAP_CTRL CHeapCtrl *MHeapCtrl(U8 *src);
public _extern _MSIZE I64 MSize(U8 *src); //size of heap object
public _extern _MSIZE2 I64 MSize2(U8 *src); //Internal size
#help_index "Memory/HeapCtrl"
public extern CHeapCtrl *HeapCtrlBPInit(CBlkPool *bp,I64 pages512);
public extern U0 HeapCtrlDel(CHeapCtrl *hc);
public extern CHeapCtrl *HeapCtrlInit(CHeapCtrl *hc=NULL,CTask *task=NULL,CBlkPool *bp);
#help_index "Memory/Page Tables"
public extern Bool MemLowPagesProtect(Bool val=TRUE);
public extern Bool MemPagePresentMark(U8 *a,Bool val);
@@ -550,11 +539,11 @@ public extern U0 QSortI64(I64 *base,I64 num, I64 (*fp_compare)(I64 e1,I64 e2));
public extern U0 ProgressBarsRst();
#help_index "MultiCore"
extern U0 APSethTask();
extern U0 BSPStartMP();
public extern U0 MPInt(U8 num,I64 cpu_num=1);
public extern U0 MPIntAll(U8 num);
public extern U0 MPNMInt();
extern U0 MPSethServerTask();
extern U0 MPStart();
public extern U0 MPWake(I64 target_cpu);
extern CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
U8 *task_name=NULL,I64 target_cpu,
@@ -564,7 +553,7 @@ extern CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
#help_index "MultiCore;Boot"
public extern U0 MPHalt();
#help_index "MultiCore;Task/Srv"
#help_index "MultiCore;Task/Srv/Exe"
public extern CSrvCmd *JobQue(I64 (*fp_addr)(U8 *data),U8 *data=NULL,
I64 target_cpu=1,I64 flags=1<<SVCf_FREE_ON_COMPLETE,
I64 cmd_code=SVCT_CALL,U8 *aux_str=NULL,I64 aux1=0,I64 aux2=0);
@@ -598,8 +587,7 @@ public extern CSndGlbls snd;
public extern U0 Exit();
public extern Bool IsPreempt();
public extern Bool IsSuspended(CTask *task=NULL);
public extern U0 Kill(CTask *task,Bool wait=TRUE);
public extern CTask *SpawnUser(U8 *fmt=NULL,...);
public extern Bool Kill(CTask *task,Bool wait=TRUE);
public extern Bool Suspend(CTask *task=NULL,Bool state=TRUE);
_extern _TASK_CONTEXT_RESTORE U0 TaskContextRestore();
_extern _TASK_END_NOW U0 TaskEndNow();
@@ -609,6 +597,7 @@ public extern U0 TaskQueIns(CTask *task,CTask *pred=NULL);
public extern U0 TaskQueRem(CTask *task);
public extern Bool TaskValidate(CTask *task);
public extern U0 TaskWait(CTask *task=NULL);
public extern CTask *User(U8 *fmt=NULL,...);
public extern U0 UserCmdLine();
public _extern _YIELD U0 Yield();
public extern CTask *adam_task;
@@ -632,30 +621,33 @@ public extern U0 TaskDerivedValsUpdate(CTask *task=NULL,Bool update_z_buf=TRUE);
public extern U0 WinDerivedValsUpdate(CTask *task=NULL);
#help_index "Task/Srv"
#help_file "::/Doc/TaskSrv"
#help_index "Task/Srv/Exe"
public extern I64 Adam(U8 *fmt,...);
public extern U0 AdamErr(U8 *fmt,...);
public extern U0 AdamLog(U8 *fmt,...);
public extern I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL);
public extern I64 PopUpPrint(U8 *fmt,...);
public extern U0 SrvCmdDel(CSrvCmd *tempc);
extern U0 SrvCmdLine();
public extern I64 SrvCmdsHandler(CTask *task=NULL);
public extern U0 SrvTaskCont();
public extern I64 SrvUser(U8 *fmt,...);
extern U0 SrvUserCmdLine();
public extern CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags);
public extern U0 TaskRstAwaitingMsg(CTask *task=NULL);
#help_index "Task/Srv;Compiler"
#help_index "Task/Srv/Exe;Compiler"
public extern I64 ExeCmdLine(CLex *lx);
public extern U0 UserTaskCont();
#help_index "Task/Srv;MultiCore"
#help_index "Task/Srv/Exe;MultiCore"
public extern I64 GetResult(CSrvCmd *rqst=NULL);
public extern Bool ScanResult(CSrvCmd *rqst=NULL,I64 *_result=NULL);
#help_index "Task/Text & Msgs"
public extern CSrvCmd *TaskText(CTask *srv,CTask *master,
U8 *data,I64 flags);
#help_index "Task/Srv/Text & Msgs"
public extern CSrvCmd *TaskText(CTask *srv,CTask *master,U8 *data,I64 flags);
#help_index "Task/Text & Msgs;AutoFile"
#help_index "Task/Srv/Text & Msgs;AutoFile"
public extern U0 Auto(U8 *fmt,...);
public extern U0 AutoFile(U8 *filename);
public extern U0 AutoStr(U8 *fmt,...);
@@ -664,14 +656,14 @@ public extern U0 XTalkStr(CTask *task,U8 *fmt,...);
public extern U0 XTalkStrWait(CTask *task,U8 *fmt,...);
public extern U0 XTalkWait(CTask *task,U8 *fmt,...);
#help_index "Task/Text & Msgs;Messages"
#help_index "Task/Srv/Text & Msgs;Messages"
public extern U0 Msg(I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern U0 PostMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern U0 SendMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern CSrvCmd *TaskMsg(CTask *srv,CTask *master,
I64 msg_code,I64 a1,I64 a2,I64 flags);
#help_index "Task;MultiCore"
#help_index "Task;Task/Srv/Exe;MultiCore"
public extern CTask *Spawn(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
U8 *task_name=NULL,I64 target_cpu=-1, //-1 means current CPU
CTask *parent=NULL, //NULL means adam
Kernel/KeyDev.CPP
+1 -1
View File
@@ -51,7 +51,7 @@ U0 PutS(U8 *st)
}
}
U0 SetKeyDesc(U8 *fmt,...)
U0 KeyDescSet(U8 *fmt,...)
{//Call this from key handler to report desc in $LK,"KeyMap",A="MN:KeyMap"$().
I64 i;
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
Kernel/Math1b.CPP
-178
View File
@@ -1,178 +0,0 @@
F64 Clamp(F64 num,F64 lo,F64 hi)
{//Clamp to F64 [] range.
if (num<lo)
return lo;
if (num>hi)
return hi;
return num;
}
F64 Min(F64 n1,F64 n2)
{//Min of two F64s.
if (n1<=n2)
return n1;
else
return n2;
}
F64 Max(F64 n1,F64 n2)
{//Max of two F64s.
if (n1>=n2)
return n1;
else
return n2;
}
F64 Pow10I64(I64 i)
{//F64 integer powers of ten.
if (i>308)
return ì;
else if (i<-308)
return 0.0;
else
return pow10_I64[i+309];
}
U64 FloorU64(U64 num,U64 to)
{//Integer multiples of num.
return num-num%to;
}
U64 CeilU64(U64 num,U64 to)
{//Integer multiples of num.
num+=to-1;
return num-num%to;
}
I64 RoundI64(I64 num,I64 to)
{//Integer multiples of num.
return num-num%to;
}
I64 FloorI64(I64 num,I64 to)
{//Integer multiples of num.
if (num>=0)
return num-num%to;
else {
num++;
return num-num%to-to;
}
}
I64 CeilI64(I64 num,I64 to)
{//Integer multiples of num.
if (num>=0) {
num+=to-1;
return num-num%to;
} else {
num+=to-1;
return num-num%to-to;
}
}
//See $LK,"::/Doc/Acknowledgements.TXT"$.
I16 RandI16()
{//Random I16. Xor with TimsStamp.
sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
return sys_rnd_seed.i16[0];
}
U16 RandU16()
{//Random U16. Xor with TimsStamp.
sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
return sys_rnd_seed.u16[0];
}
I32 RandI32()
{//Random I32. Xor with TimsStamp.
sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
return sys_rnd_seed.i32[0];
}
U32 RandU32()
{//Random U32. Xor with TimsStamp.
sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
return sys_rnd_seed.u32[0];
}
I64 RandI64()
{//Random I64. Xor with TimsStamp.
I64 result;
result.u32[0]=sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
result.u32[1]=sys_rnd_seed.i32[0]= 1664525*sys_rnd_seed.i32[0]+1013904223;
return result;
}
U64 RandU64()
{//Random U64. Xor with TimsStamp.
U64 result;
result.u32[0]=sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
result.u32[1]=sys_rnd_seed.i32[0]= 1664525*sys_rnd_seed.i32[0]+1013904223;
return result;
}
F64 Rand()
{//Random F64. Xor with TimsStamp. 0.0<=x<1.0
I64 result;
result.u32[0]=sys_rnd_seed.i32[0]=(1664525*sys_rnd_seed.i32[0]+1013904223)^GetTSC>>4;
result.u32[1]=sys_rnd_seed.i32[0]= 1664525*sys_rnd_seed.i32[0]+1013904223;
result&=0x3FFFFFFFFFFFFFFF;
return result/ToF64(0x4000000000000000);
}
I16 Rand2I16()
{//Random I16. No time input.
Fs->rnd_seed.i32[0]=1664525*Fs->rnd_seed.i32[0]+1013904223;
return Fs->rnd_seed.i16[0];
}
U16 Rand2U16()
{//Random U16. No time input.
Fs->rnd_seed.i32[0]=1664525*Fs->rnd_seed.i32[0]+1013904223;
return Fs->rnd_seed.u16[0];
}
I32 Rand2I32()
{//Random I32. No time input.
Fs->rnd_seed.i32[0]=1664525*Fs->rnd_seed.i32[0]+1013904223;
return Fs->rnd_seed.i32[0];
}
U32 Rand2U32()
{//Random U32. No time input.
Fs->rnd_seed.i32[0]=1664525*Fs->rnd_seed.i32[0]+1013904223;
return Fs->rnd_seed.u32[0];
}
I64 Rand2I64()
{//Random I64. No time input.
I64 result;
result.u32[0]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
result.u32[1]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
return result;
}
U64 Rand2U64()
{//Random U64. No time input.
U64 result;
result.u32[0]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
result.u32[1]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
return result;
}
F64 Rand2()
{//Random F64. No time input. 0.0<=x<1.0
I64 result;
result.u32[0]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
result.u32[1]=Fs->rnd_seed.i32[0]= 1664525*Fs->rnd_seed.i32[0]+1013904223;
result&=0x3FFFFFFFFFFFFFFF;
return result/ToF64(0x4000000000000000);
}
U0 Randomize(I64 seed=0)
{//Randomizes $LK,"CTask",A="MN:CTask"$ seed.
if (seed)
Fs->rnd_seed=seed;
else
Fs->rnd_seed=GetTSC>>4;
}
Kernel/Mem1a.CPP → Kernel/MemA.CPP
+33 -30
View File
@@ -1,5 +1,5 @@
asm {
/*See $LK,"::/Doc/Acknowledgements.TXT"$.
/*See $LK,"::/Doc/Credits.TXT"$.
See $LK,"::/Doc/MemOverview.TXT"$
*/
@@ -9,7 +9,7 @@ SYS_INIT_MEM::
MOV EDI,SYS_FIXED_AREA
XOR EAX,EAX
MOV ECX,sizeof(CSysFixedArea)/4
REP_STOSD
REP_STOSD //Init entire SYS_FIXED_AREA to zero
//PML1
MOV EAX,0x107
@@ -24,7 +24,7 @@ SYS_INIT_MEM::
ADC EDX,0
LOOP @@05
//0xA0000-0xBFFFF: video ram=write through
//0xA0000-0xBFFFF: video ram=write thru
MOV EAX,0xF
XOR EDX,EDX
MOV EDI,SYS_FIXED_AREA+CSysFixedArea.pml1+0xA0*8
@@ -146,7 +146,8 @@ pain without MAlloc up-and-running.
MOV U32 CBlkPool.mem_free_lst+4[ESI],0
MOV U32 CMemBlk.mb_signature[EBX],MBS_UNUSED_SIGNATURE_VAL
MOV U32 CMemBlk.pages[EBX],EAX
ADD U32 CBlkPool.size[ESI],EAX
SHL EAX,PAGE_BITS
ADD U32 CBlkPool.alloced_u8s[ESI],EAX
RET
}
@@ -188,9 +189,9 @@ Bool MemPagePresentMark(U8 *a,Bool val)
return result;
}
U8 *MemBlksIndependentAlloc(I64 *_pages512,CBlkPool *bp=NULL)
{/*Alloc 512Byte pages from bp. Don't link to task.
(Linking to a task means it will be freed when the task dies.)
U8 *Mem512Alloc(I64 *_pages512,CBlkPool *bp=NULL)
{/*Alloc 512Byte pages from BlkPool. Don't link to task.
(Linking to a task means they will be freed when the task dies.)
It might give you more than you asked for
so a ptr to a page count is passed.
@@ -255,14 +256,14 @@ Return: NULL if out of memory.
}
at_done:
*_pages512=num;
bp->allocated_u8s+=num<<PAGE_BITS;
bp->used_u8s+=num<<PAGE_BITS;
LBtr(&bp->locked_flags,BPlf_LOCKED);
POPFD
return result;
}
U0 MemBlksNonTaskFree(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL)
{//Return nontask 512Byte pages(s) to bp.
U0 Mem512Free(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL)
{//Return non-task 512Byte pages to BlkPool.
I64 i;
if (m) {
if (!bp) bp=sys_code_bp;
@@ -272,7 +273,7 @@ U0 MemBlksNonTaskFree(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL)
PAUSE
m->mb_signature=MBS_UNUSED_SIGNATURE_VAL;
m->pages=pages512;
bp->allocated_u8s-=pages512<<PAGE_BITS;
bp->used_u8s-=pages512<<PAGE_BITS;
if (pages512<FREE_PAGE_HASH_SIZE) {
m->next=bp->free_page_hash[pages512];
bp->free_page_hash[pages512]=m;
@@ -292,8 +293,8 @@ U0 MemBlksNonTaskFree(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL)
}
}
U8 *MemBlks2MegAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from bp. Don't link to task.
U8 *Mem2MegAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from BlkPool. Don't link to task.
(Linking to a task means they will be freed when the task dies.)
It might give you more than you asked for
so a ptr to a page count is passed.
@@ -381,7 +382,7 @@ Return: NULL if out of memory.
}
am_done:
i=num<<PAGE_BITS;
bp->allocated_u8s+=i;
bp->used_u8s+=i;
num>>=21-PAGE_BITS;
*_pages2Meg=num;
m=result;
@@ -397,9 +398,9 @@ am_done:
return result;
}
U8 *MemBlksUncachedAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from bp. Don't link to task.
(Linking to a task means it will be freed when the task dies.)
U8 *Mem2MegUncachedAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from BlkPool. Don't link to task.
(Linking to a task means they will be freed when the task dies.)
It will be marked uncached. It might give you more than you asked for
so a ptr to a page count is passed.
@@ -407,7 +408,7 @@ Return: NULL if out of memory.
*/
CMemBlk *result,*m,*m1;
I64 num=*_pages2Meg,*pte;
if (result=MemBlks2MegAlloc(_pages2Meg,bp)) {
if (result=Mem2MegAlloc(_pages2Meg,bp)) {
num=*_pages2Meg;
m=result;
m1=m(U8 *)+num<<21;
@@ -421,8 +422,8 @@ Return: NULL if out of memory.
return result;
}
U8 *MemBlksWriteThroughAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from bp. Don't link to task.
U8 *Mem2MegWriteThruAlloc(I64 *_pages2Meg,CBlkPool *bp=NULL)
{/*Alloc 2Meg pages from BlkPool. Don't link to task.
(Linking to a task means they will be freed when the task dies.)
It will be marked write-through. It might give you more than you asked for
so a ptr to a page count is passed.
@@ -431,7 +432,7 @@ Return: NULL if out of memory.
*/
CMemBlk *result,*m,*m1;
I64 num=*_pages2Meg,*pte;
if (result=MemBlks2MegAlloc(_pages2Meg,bp)) {
if (result=Mem2MegAlloc(_pages2Meg,bp)) {
num=*_pages2Meg;
m=result;
m1=m(U8 *)+num<<21;
@@ -445,8 +446,8 @@ Return: NULL if out of memory.
return result;
}
U0 MemBlks2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL)
{//Return 2Meg page(s) to bp.
U0 Mem2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL)
{//Return non-task 2Meg pages to BlkPool.
I64 *pte;
CMemBlk *m1,*m2;
if (m) {
@@ -465,7 +466,7 @@ U0 MemBlks2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL)
PAUSE
m->mb_signature=MBS_UNUSED_SIGNATURE_VAL;
m->pages=pages2Meg<<(21-PAGE_BITS);
bp->allocated_u8s-=pages2Meg<<21;
bp->used_u8s-=pages2Meg<<21;
m->next=bp->mem_free_2meg_lst;
bp->mem_free_2meg_lst=m;
LBtr(&bp->locked_flags,BPlf_LOCKED);
@@ -473,7 +474,7 @@ U0 MemBlks2MegFree(CMemBlk *m,I64 pages2Meg,CBlkPool *bp=NULL)
}
}
CMemBlk *MemBlksAlloc(I64 *_pages512,CHeapCtrl *hc)
CMemBlk *Mem512TaskAlloc(I64 *_pages512,CHeapCtrl *hc)
{/*hc must be locked. Interrupts should probably be off
Currently, this is only called from $LK,"MAlloc",A="MN:MAlloc"$().
@@ -481,10 +482,11 @@ Return: NULL if out of memory.
*/
CMemBlk *result;
I64 threshold,cnt,size;
CMemUnusedAllocated *uum,**_uum,**_ptr;
if (result=MemBlksIndependentAlloc(_pages512,hc->bp)) {
CMemUnused *uum,**_uum,**_ptr;
if (result=Mem512Alloc(_pages512,hc->bp)) {
QueIns(result,hc->last_mem_blk);
result->mb_signature=MBS_USED_SIGNATURE_VAL;
hc->alloced_u8s+=*_pages512<<PAGE_BITS;
//Tidy-up free lst (Move into heap hash)
//because if free lst gets long, delay causes crash
@@ -494,7 +496,7 @@ Return: NULL if out of memory.
cnt=0;
_uum=&hc->malloc_free_lst;
while (uum=*_uum) {
#assert !offset(CMemUnusedAllocated.next)
#assert !offset(CMemUnused.next)
size=uum->size;
if (size<threshold) {
*_uum=uum->next;
@@ -512,7 +514,7 @@ Return: NULL if out of memory.
return result;
}
U0 MemBlksFree(CMemBlk *m,CHeapCtrl *hc)
U0 Mem512TaskFree(CMemBlk *m,CHeapCtrl *hc)
{//hc must be locked
if (m) {
PUSHFD
@@ -521,7 +523,8 @@ U0 MemBlksFree(CMemBlk *m,CHeapCtrl *hc)
SysBadFree(m);
else {
QueRem(m);
MemBlksNonTaskFree(m,m->pages,hc->bp);
hc->alloced_u8s-=m->pages<<PAGE_BITS;
Mem512Free(m,m->pages,hc->bp);
}
POPFD
}
Kernel/Mem1b.CPP → Kernel/MemB.CPP
+74 -74
View File
@@ -27,12 +27,12 @@ _MALLOC::
@@15: MOV RAX,U64 SF_ARG1[RBP]
PUSHFD
ADD RAX,CMemUsedAllocated.start+7 //round-up to I64
ADD RAX,CMemUsed.start+7 //round-up to I64
AND AL,0xF8
#assert CMemUsedAllocated.start>=sizeof(CMemUnusedAllocated)
CMP RAX,CMemUsedAllocated.start
#assert CMemUsed.start>=sizeof(CMemUnused)
CMP RAX,CMemUsed.start
JAE @@20
MOV RAX,CMemUsedAllocated.start
MOV RAX,CMemUsed.start
@@20:
CLI
@@ -46,7 +46,7 @@ _MALLOC::
MOV RSI,U64 CHeapCtrl.heap_hash[RAX+RDX]
TEST RSI,RSI
JZ @@35
MOV RCX,U64 CMemUnusedAllocated.next[RSI]
MOV RCX,U64 CMemUnused.next[RSI]
MOV U64 CHeapCtrl.heap_hash[RAX+RDX],RCX
JMP I32 MALLOC_ALMOST_DONE
@@ -54,14 +54,14 @@ _MALLOC::
@@30: ADD RAX,sizeof(CMemBlk)+PAGE_SIZE-1
SHR RAX,PAGE_BITS
PUSH RDX //preserve heap ctrl
PUSH RDX //preserve HeapCtrl
PUSH RAX //num blks (we must pass address of this)
MOV RAX,RSP
PUSH RDX
PUSH RAX //addr of num blks
CALL &MemBlksAlloc
CALL &Mem512TaskAlloc
MOV RSI,RAX
POP RAX //blks that were allocated
POP RAX //blks that were alloced
POP RDX
TEST RSI,RSI
JZ @@45 //Out of memory
@@ -72,24 +72,24 @@ _MALLOC::
JMP I32 MALLOC_ALMOST_DONE
//Little allocation, chunk-off piece from free lst chunks
@@35: LEA RSI,U64 CHeapCtrl.malloc_free_lst-CMemUnusedAllocated.next[RDX]
@@35: LEA RSI,U64 CHeapCtrl.malloc_free_lst-CMemUnused.next[RDX]
@@40: MOV RBX,RSI
MOV RSI,U64 CMemUnusedAllocated.next[RBX]
MOV RSI,U64 CMemUnused.next[RBX]
TEST RSI,RSI
JNZ @@55
PUSH RAX //-**** save byte size
ADD RAX,16*PAGE_SIZE-1
SHR RAX,PAGE_BITS
PUSH RDX //preserve heap ctrl
PUSH RDX //preserve HeapCtrl
PUSH RAX //num blks (we must pass address of this)
MOV RAX,RSP
PUSH RDX
PUSH RAX //addr of num blks
CALL &MemBlksAlloc
CALL &Mem512TaskAlloc
MOV RSI,RAX
POP RAX //blks that were allocated
POP RAX //blks that were alloced
POP RDX
TEST RSI,RSI
JNZ @@50
@@ -107,43 +107,43 @@ _MALLOC::
@@50: LEA RSI,U64 sizeof(CMemBlk)[RSI]
SHL RAX,PAGE_BITS
SUB RAX,sizeof(CMemBlk)
LEA RBX,U64 CHeapCtrl.malloc_free_lst-CMemUnusedAllocated.next[RDX]
MOV RDI,U64 CMemUnusedAllocated.next[RBX]
MOV U64 CMemUnusedAllocated.next[RSI],RDI
MOV U64 CMemUnusedAllocated.size[RSI],RAX
MOV U64 CMemUnusedAllocated.next[RBX],RSI
LEA RBX,U64 CHeapCtrl.malloc_free_lst-CMemUnused.next[RDX]
MOV RDI,U64 CMemUnused.next[RBX]
MOV U64 CMemUnused.next[RSI],RDI
MOV U64 CMemUnused.size[RSI],RAX
MOV U64 CMemUnused.next[RBX],RSI
POP RAX //+****
JMP @@65
@@55: CMP U64 CMemUnusedAllocated.size[RSI],RAX
@@55: CMP U64 CMemUnused.size[RSI],RAX
JB @@40
JNE @@65
@@60: MOV RDI,U64 CMemUnusedAllocated.next[RSI]
MOV U64 CMemUnusedAllocated.next[RBX],RDI
@@60: MOV RDI,U64 CMemUnused.next[RSI]
MOV U64 CMemUnused.next[RBX],RDI
JMP MALLOC_ALMOST_DONE
@@65: SUB U64 CMemUnusedAllocated.size[RSI],RAX //UPDATE FREE ENTRY
CMP U64 CMemUnusedAllocated.size[RSI],sizeof(CMemUnusedAllocated)
@@65: SUB U64 CMemUnused.size[RSI],RAX //UPDATE FREE ENTRY
CMP U64 CMemUnused.size[RSI],sizeof(CMemUnused)
JAE @@70 //take from top of block
ADD U64 CMemUnusedAllocated.size[RSI],RAX //doesn't fit, undo
ADD U64 CMemUnused.size[RSI],RAX //doesn't fit, undo
JMP I32 @@40
@@70: ADD RSI,U64 CMemUnusedAllocated.size[RSI]
@@70: ADD RSI,U64 CMemUnused.size[RSI]
MALLOC_ALMOST_DONE:
//RSI=result-CMemUsedAllocated.size
//RAX=size+CMemUsedAllocated.size
//RDX=heap ctrl
//RSI=result-CMemUsed.size
//RAX=size+CMemUsed.size
//RDX=HeapCtrl
ADD U64 CHeapCtrl.used_u8s[RDX],RAX
#if _CFG_HEAP_DBG
//QueIns
MOV RDI,U64 CHeapCtrl.last_um[RDX]
MOV U64 CMemUsedAllocated.next[RDI],RSI
MOV U64 CMemUsed.next[RDI],RSI
MOV U64 CHeapCtrl.last_um[RDX],RSI
MOV U64 CMemUsedAllocated.last[RSI],RDI
LEA RDI,U64 CHeapCtrl.next_um-CMemUsedAllocated.next[RDX]
MOV U64 CMemUsedAllocated.next[RSI],RDI
MOV U64 CMemUsed.last[RSI],RDI
LEA RDI,U64 CHeapCtrl.next_um-CMemUsed.next[RDX]
MOV U64 CMemUsed.next[RSI],RDI
//Caller1/Caller2
PUSH RDX
@@ -152,9 +152,9 @@ MALLOC_ALMOST_DONE:
CMP RDI,RDX
JB @@75
XOR RDI,RDI
MOV U64 CMemUsedAllocated.caller1[RSI],RDI
MOV U64 CMemUsed.caller1[RSI],RDI
JMP @@85
@@75: MOV U64 CMemUsedAllocated.caller1[RSI],RDI
@@75: MOV U64 CMemUsed.caller1[RSI],RDI
MOV RDI,U64 SF_RBP[RBP]
CMP RDI,RDX
JB @@80
@@ -164,7 +164,7 @@ MALLOC_ALMOST_DONE:
CMP RDI,RDX
JB @@85
XOR RDI,RDI
@@85: MOV U64 CMemUsedAllocated.caller2[RSI],RDI
@@85: MOV U64 CMemUsed.caller2[RSI],RDI
POP RDX
#endif
@@ -172,9 +172,9 @@ MALLOC_ALMOST_DONE:
BTR U32 CHeapCtrl.locked_flags[RDX],HClf_LOCKED
POPFD
MOV U64 CMemUsedAllocated.size[RSI],RAX
MOV U64 CMemUsedAllocated.hc[RSI],RDX
LEA RAX,U64 CMemUsedAllocated.start[RSI]
MOV U64 CMemUsed.size[RSI],RAX
MOV U64 CMemUsed.hc[RSI],RDX
LEA RAX,U64 CMemUsed.start[RSI]
TEST U8 [SYS_SEMAS+SYS_SEMA_HEAPLOG_ACTIVE*SEMA_STRUCT_SIZE],1
JZ @@100
@@ -193,8 +193,8 @@ MALLOC_ALMOST_DONE:
JZ MALLOC_FINAL_EXIT
PUSH RAX
MOV RCX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RAX]
SUB RCX,CMemUsedAllocated.start
MOV RCX,U64 CMemUsed.size-CMemUsed.start[RAX]
SUB RCX,CMemUsed.start
MOV RDI,RAX
MOV AL,U8 [SYS_HEAP_INIT_VAL]
REP_STOSB
@@ -207,7 +207,7 @@ MALLOC_FINAL_EXIT:
RET1 16
//************************************
_FREE::
//Be aware of $LK,"heap_hash",A="FF:::/Kernel/Mem1b.CPP,heap_hash"$ in $LK,"MemBlksAlloc",A="MN:MemBlksAlloc"$().
//Be aware of $LK,"heap_hash",A="FF:::/Kernel/MemB.CPP,heap_hash"$ in $LK,"Mem512TaskAlloc",A="MN:Mem512TaskAlloc"$().
PUSH RBP
MOV RBP,RSP
PUSH RSI
@@ -218,7 +218,7 @@ _FREE::
MOV RBX,U64 SF_ARG1[RBP]
TEST RBX,RBX
JZ @@05
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
TEST RAX,RAX
JGE @@05 //Aligned alloced chunks have neg size
ADD RBX,RAX
@@ -240,23 +240,23 @@ _FREE::
JZ FREE_DONE
#endif
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RSI]
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RSI]
TEST RAX,RAX
JGE @@20 //Aligned alloced chunks have neg size.
//The neg size is offset to start of $LK,"CMemUsedAllocated",A="MN:CMemUsedAllocated"$ struct.
//The neg size is offset to start of $LK,"CMemUsed",A="MN:CMemUsed"$ struct.
ADD RSI,RAX
@@20: PUSHFD
SUB RSI,CMemUsedAllocated.start
MOV RDX,U64 CMemUsedAllocated.hc[RSI]
SUB RSI,CMemUsed.start
MOV RDX,U64 CMemUsed.hc[RSI]
CMP U32 CHeapCtrl.hc_signature[RDX],HEAP_CTRL_SIGNATURE_VAL
JE @@25
ADD RSI,CMemUsedAllocated.start
ADD RSI,CMemUsed.start
PUSH RSI
CALL &SysBadFree
JMP I32 _SYS_HLT
@@25: MOV RAX,U64 CMemUsedAllocated.size[RSI]
@@25: MOV RAX,U64 CMemUsed.size[RSI]
SUB U64 CHeapCtrl.used_u8s[RDX],RAX
CLI
@@30: LOCK
@@ -265,10 +265,10 @@ _FREE::
JC @@30
#if _CFG_HEAP_DBG
//QueRem
MOV RDX,U64 CMemUsedAllocated.next[RSI]
MOV RDI,U64 CMemUsedAllocated.last[RSI]
MOV U64 CMemUsedAllocated.last[RDX],RDI
MOV U64 CMemUsedAllocated.next[RDI],RDX
MOV RDX,U64 CMemUsed.next[RSI]
MOV RDI,U64 CMemUsed.last[RSI]
MOV U64 CMemUsed.last[RDX],RDI
MOV U64 CMemUsed.next[RDI],RDX
//Caller1/Caller2
MOV RDX,U64 [SYS_HEAP_LIMIT]
@@ -276,9 +276,9 @@ _FREE::
CMP RDI,RDX
JB @@35
XOR RDI,RDI
MOV U64 CMemUnusedAllocated.caller1[RSI],RDI
MOV U64 CMemUnused.caller1[RSI],RDI
JMP @@45
@@35: MOV U64 CMemUnusedAllocated.caller1[RSI],RDI
@@35: MOV U64 CMemUnused.caller1[RSI],RDI
MOV RDI,U64 SF_RBP[RBP]
CMP RDI,RDX
JB @@40
@@ -288,18 +288,18 @@ _FREE::
CMP RDI,RDX
JB @@45
XOR RDI,RDI
@@45: MOV U64 CMemUnusedAllocated.caller2[RSI],RDI
@@45: MOV U64 CMemUnused.caller2[RSI],RDI
MOV RDX,U64 CMemUsedAllocated.hc[RSI]
MOV RDX,U64 CMemUsed.hc[RSI]
#endif
CMP RAX,HEAP_HASH_SIZE
JAE @@50
#assert CMemUnusedAllocated.size==CMemUsedAllocated.size
// MOV U64 CMemUnusedAllocated.size[RSI],RAX
#assert CMemUnused.size==CMemUsed.size
// MOV U64 CMemUnused.size[RSI],RAX
MOV RBX,U64 CHeapCtrl.heap_hash[RAX+RDX]
MOV U64 CMemUnusedAllocated.next[RSI],RBX
MOV U64 CMemUnused.next[RSI],RBX
MOV U64 CHeapCtrl.heap_hash[RAX+RDX],RSI
JMP @@55
@@ -307,7 +307,7 @@ _FREE::
PUSH RDX
PUSH RDX
PUSH RSI
CALL &MemBlksFree
CALL &Mem512TaskFree
POP RDX
@@55: LOCK
@@ -326,12 +326,12 @@ _MSIZE::
XOR RAX,RAX
TEST RBX,RBX
JZ @@10
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
TEST RAX,RAX
JGE @@05 //Aligned alloced chunks have neg size
ADD RBX,RAX
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
@@05: SUB RAX,CMemUsedAllocated.start
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
@@05: SUB RAX,CMemUsed.start
@@10: POP RBP
RET1 8
//************************************
@@ -342,11 +342,11 @@ _MSIZE2::
XOR RAX,RAX
TEST RBX,RBX
JZ @@10
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
TEST RAX,RAX
JGE @@05 //Aligned alloced chunks have neg size
ADD RBX,RAX
@@05: MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
@@05: MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
@@10: POP RBP
RET1 8
//************************************
@@ -357,11 +357,11 @@ _MHEAP_CTRL::
XOR RAX,RAX
TEST RBX,RBX
JZ @@10
MOV RAX,U64 CMemUsedAllocated.size-CMemUsedAllocated.start[RBX]
MOV RAX,U64 CMemUsed.size-CMemUsed.start[RBX]
TEST RAX,RAX
JGE @@05 //Aligned alloced chunks have neg size
ADD RBX,RAX
@@05: MOV RAX,U64 CMemUsedAllocated.hc-CMemUsedAllocated.start[RBX]
@@05: MOV RAX,U64 CMemUsed.hc-CMemUsed.start[RBX]
@@10: POP RBP
RET1 8
}
@@ -370,11 +370,11 @@ _extern _FREE U0 Free(U8 *addr); //Free $LK,"MAlloc",A="MN:MAlloc"$()ed memory c
_extern _MSIZE I64 MSize(U8 *src); //Size of heap object.
_extern _MSIZE2 I64 MSize2(U8 *src); //Internal size of heap object.
_extern _MHEAP_CTRL CHeapCtrl *MHeapCtrl(U8 *src); //$LK,"CHeapCtrl",A="MN:CHeapCtrl"$ of object.
_extern _MALLOC U8 *MAlloc(I64 size,CTask *mem_task=NULL); //Allocate memory chunk.
_extern _MALLOC U8 *MAlloc(I64 size,CTask *mem_task=NULL); //Alloc memory chunk.
//Accepts a $LK,"CTask",A="MN:CTask"$ or $LK,"CHeapCtrl",A="MN:CHeapCtrl"$. NULL allocs off current task's heap.
U8 *AMAlloc(I64 size)
{//Allocate memory in Adam's heap.
{//Alloc memory in Adam's heap.
return MAlloc(size,adam_task);
}
@@ -386,7 +386,7 @@ U8 *CAlloc(I64 size,CTask *mem_task=NULL)
}
U8 *ACAlloc(I64 size)
{//Allocate and set to zero memory in Adam's heap.
{//Alloc and set to zero memory in Adam's heap.
return CAlloc(size,adam_task);
}
@@ -402,7 +402,7 @@ U8 *MAllocIdentical(U8 *src,CTask *mem_task=NULL)
}
U8 *AMAllocIdentical(U8 *src)
{//Allocate in Adam's heap, identical copy of heap node.
{//Alloc in Adam's heap, identical copy of heap node.
return MAllocIdentical(src,adam_task);
}
@@ -412,7 +412,7 @@ U8 *MAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0
U8 *ptr=MAlloc(size+mask+sizeof(I64)+misalignment,mem_task),
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
result(I64 *)[-1]=ptr-result;
#assert offset(CMemUsedAllocated.size)==offset(CMemUsedAllocated.start)-sizeof(I64)
#assert offset(CMemUsed.size)==offset(CMemUsed.start)-sizeof(I64)
return result;
}
@@ -422,7 +422,7 @@ U8 *CAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0
U8 *ptr=MAlloc(size+mask+sizeof(I64)+misalignment,mem_task),
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
result(I64 *)[-1]=ptr-result;
#assert offset(CMemUsedAllocated.size)==offset(CMemUsedAllocated.start)-sizeof(I64)
#assert offset(CMemUsed.size)==offset(CMemUsed.start)-sizeof(I64)
MemSet(result,0,size);
return result;
}
@@ -443,6 +443,6 @@ U8 *StrNew(U8 *buf,CTask *mem_task=NULL)
}
U8 *AStrNew(U8 *buf)
{//Allocate copy of string in Adam's heap.
{//Alloc copy of string in Adam's heap.
return StrNew(buf,adam_task);
}
Kernel/Mem1c.CPP → Kernel/MemC.CPP
+15 -12
View File
@@ -1,5 +1,5 @@
U0 BlkPoolAdd(CBlkPool *bp,CMemBlk *m,I64 pages512)
{//Add memory to blk pool.
{//Add mem to BlkPool.
if (sys_mem_init_flag)
MemSet(m,sys_mem_init_val,pages512*512);
PUSHFD
@@ -9,20 +9,20 @@ U0 BlkPoolAdd(CBlkPool *bp,CMemBlk *m,I64 pages512)
m->next=bp->mem_free_lst;
m->pages=pages512;
m->mb_signature=MBS_UNUSED_SIGNATURE_VAL;
bp->size+=pages512;
bp->alloced_u8s+=pages512<<PAGE_BITS;
bp->mem_free_lst=m;
LBtr(&bp->locked_flags,BPlf_LOCKED);
POPFD
}
U0 BlkPoolInit(CBlkPool *bp,I64 pages512)
{//Make memory chunk into a blk pool.
{//Make mem chunk into a BlkPool.
I64 num;
CMemBlk *m;
MemSet(bp,0,sizeof(CBlkPool));
m=(bp(U8 *)+sizeof(CBlkPool)+PAGE_SIZE-1)&~(PAGE_SIZE-1);
num=(bp(U8 *)+pages512<<PAGE_BITS-m(U8 *))>>PAGE_BITS;
bp->size=pages512-num; //Compensate before num added.
bp->alloced_u8s=(pages512-num)<<PAGE_BITS; //Compensate before num added.
BlkPoolAdd(bp,m,num);
}
@@ -34,12 +34,12 @@ CHeapCtrl *HeapCtrlInit(CHeapCtrl *hc=NULL,CTask *task=NULL,CBlkPool *bp)
hc->mem_task=task;
hc->bp=bp;
QueInit(&hc->next_mem_blk);
hc->next_um=hc->last_um=(&hc->next_um)(U8 *)-offset(CMemUsedAllocated.next);
hc->next_um=hc->last_um=(&hc->next_um)(U8 *)-offset(CMemUsed.next);
return hc;
}
CHeapCtrl *HeapCtrlBPInit(CBlkPool *bp,I64 pages512)
{//Make memory chunk into heap ctrl and blk pool.
{//Make mem chunk into HeapCtrl and BlkPool.
I64 num;
CMemBlk *m;
CHeapCtrl *hc;
@@ -47,13 +47,13 @@ CHeapCtrl *HeapCtrlBPInit(CBlkPool *bp,I64 pages512)
hc=HeapCtrlInit(bp(U8 *)+sizeof(CBlkPool),,bp);
m=(bp(U8 *)+sizeof(CBlkPool)+sizeof(CHeapCtrl)+PAGE_SIZE-1)&~(PAGE_SIZE-1);
num=(bp(U8 *)+pages512<<PAGE_BITS-m(U8 *))>>PAGE_BITS;
bp->size=pages512-num;
bp->alloced_u8s=(pages512-num)<<PAGE_BITS;
BlkPoolAdd(bp,m,num);
return hc;
}
U0 HeapCtrlDel(CHeapCtrl *hc)
{//Free all blks alloced to a heap ctrl.
{//Free all blks alloced to a HeapCtrl.
CMemBlk *m,*m1;
if (hc) {
PUSHFD
@@ -63,7 +63,7 @@ U0 HeapCtrlDel(CHeapCtrl *hc)
m=hc->next_mem_blk;
while (m!=&hc->next_mem_blk) {
m1=m->next;
MemBlksFree(m,hc);
Mem512TaskFree(m,hc);
m=m1;
}
LBtr(&hc->locked_flags,HClf_LOCKED);
@@ -305,9 +305,12 @@ U0 HeapsInit()
I64 Scale2Mem(I64 min,I64 max,I64 limit=2*1024*1024*1024)
{//Helps pick DiskCache and RAMDisk sizes.
//Can be used in $LK,"MakeOSPrtBootInstall",A="MN:MakeOSPrtBootInstall"$() config scripts.
//Scale-back allocations if less than 2048 Meg.
I64 i=sys_code_bp->size<<PAGE_BITS;
//Can be used in $LK,"MakeOSDrvBootInstall",A="MN:MakeOSDrvBootInstall"$() config scripts.
I64 i;
if (sys_data_bp)
i=sys_data_bp->alloced_u8s;
else
i=sys_code_bp->alloced_u8s;
if (i>=limit)
return max;
else
Kernel/MultiProc.CPP
+26 -33
View File
@@ -5,33 +5,28 @@ USE16
//This code gets copied to $LK,"MP_VECT_ADDR",A="MN:MP_VECT_ADDR"$.
//See $LK,"MemCpy(MP_VECT_ADDR",A="FF:::/Kernel/MultiProc.CPP,MemCpy(mp:2"$.
SYS_MP_INIT_START::
JMP MP2_START2
AP_16BIT_INIT::
JMP @@05
ALIGN 4,OC_NOP
MP2_SYS_TEMP_PTR: DU32 0,0;
MP2_START2:
CLI
AP_GDT_PTR: DU16 sizeof(CGDT)-1;
DU64 0;
@@05: CLI
WBINVD
MOV AX,MP_VECT_ADDR/16
MOV DS,AX
//See $LK,"mp->sys_temp_ptr",A="FF:::/Kernel/MultiProc.CPP,mp->sys_temp_ptr:2"$
#assert MP2_SYS_TEMP_PTR-SYS_MP_INIT_START==CMPMain.sys_temp_ptr
LGDT U32 [CMPMain.sys_temp_ptr]
LGDT U32 [CAP16BitInit.ap_gdt_ptr] //See $LK,"mp->ap_gdt_ptr",A="FF:::/Kernel/MultiProc.CPP,mp->ap_gdt_ptr:2"$
MOV EAX,SYS_START_CR0
MOV_CR0_EAX
DU8 0x66,0xEA; //JMP CGDT.cs32:MP_INIT_OS
DU32 MP_INIT_OS;
DU8 0x66,0xEA; //JMP CGDT.cs32:AP_32BIT_INIT
DU32 AP_32BIT_INIT;
DU16 CGDT.cs32;
AP_16BIT_INIT_END::
SYS_MP_INIT_END::
USE32
MP_INIT_OS:
AP_32BIT_INIT:
MOV AX,CGDT.ds
MOV DS,AX
MOV ES,AX
@@ -58,8 +53,8 @@ MP_INIT_OS:
LEA ESP,U32 CCPU.start_stk+sizeof(CCPU.start_stk)[ESI]
PUSH U32 SYS_START_RFLAGS
POPFD
PUSH U32 0
CALL INIT_EM64T
PUSH U32 0 //Return from next call will be 64-bit
CALL SYS_EM64T
USE64
FNINIT
MOV RAX,RSI
@@ -193,7 +188,7 @@ U0 MPWake(I64 target_cpu)
U0 MPAPICInit()
{//Called by adam during start-up
//and other cores during initialization
//after $LK,"MPStart",A="MN:MPStart"$().
//after $LK,"BSPStartMP",A="MN:BSPStartMP"$().
*LAPIC_SVR(U32 *)|=LAPICF_APIC_ENABLED;
dev.mp_apic_ids[Gs->num]=*LAPIC_APIC_ID(U32 *)>>24;
*LAPIC_LDR(U32 *)=dev.mp_apic_ids[Gs->num]<<24;
@@ -213,7 +208,7 @@ U0 MPAPICInit()
#assert !offset(CSrvCtrl.next_waiting)
U0 MPSethServerTask()
U0 APSethTask()
{
CSrvCtrl *my_ctrl=&Fs->srv_ctrl;
CSrvCmd *tempc,*tempc1=&my_ctrl->next_waiting;
@@ -222,7 +217,6 @@ U0 MPSethServerTask()
TaskFinishOffDying;
if (!LBts(&my_ctrl->flags,SVCRf_LOCKED)) {
tempc=tempc1->next;
//Jobs for this core are highest priority.
if (tempc==tempc1 || !SrvCmdRun(tempc,GetRFlags)) {
LBtr(&my_ctrl->flags,SVCRf_LOCKED) ;
if (my_ctrl->next_waiting==my_ctrl) {
@@ -296,20 +290,20 @@ CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
return result;
}
U0 MPCPUTaskInit()
{//Called by multicore's seth task after $LK,"MPStart",A="MN:MPStart"$()
U0 APSethInit()
{//Called by multicore's seth task after $LK,"BSPStartMP",A="MN:BSPStartMP"$()
//as the first thing a CPU does before waiting for jobs.
MPAPICInit;
Fs->rip=&MPSethServerTask;
Fs->rip=&APSethTask;
Fs->time_slice_start=GetTSC;
TaskContextRestore;
}
U0 MPStart()
{//Called by adam during $LK,"start-up",A="FF:::/Kernel/KEnd.CPP,MPStart"$.
U0 BSPStartMP()
{//Called by adam during $LK,"start-up",A="FF:::/Kernel/KEnd.CPP,BSPStartMP"$.
CTask *task;
U8 buf[128];
CMPMain *mp=MP_VECT_ADDR;
CAP16BitInit *mp=MP_VECT_ADDR;
CCPU *c;
I64 i,my_mp_cnt;
CRAXRBCRCXRDX ee;
@@ -334,9 +328,8 @@ U0 MPStart()
//When you start-up other cores, they jump to an addr
//specified by a byte vect number, $LK,"MPN_VECT",A="MN:MPN_VECT"$ which corresponds
//to a location 4096*vect number, $LK,"MP_VECT_ADDR",A="MN:MP_VECT_ADDR"$$WW,0$.
MemCpy(mp,SYS_MP_INIT_START,SYS_MP_INIT_END-SYS_MP_INIT_START);
mp->sys_temp_ptr=sizeof(CGDT)-1+(&sys_gdt)(U8 *)<<16;
MemCpy(mp,AP_16BIT_INIT,AP_16BIT_INIT_END-AP_16BIT_INIT);
MemCpy(&mp->ap_gdt_ptr,SYS_GDT_PTR,sizeof(CSysLimitBase));
mp_cnt_initial=mp_cnt=1;
mp_cnt_lock=0;
@@ -360,9 +353,9 @@ U0 MPStart()
for (i=1;i<my_mp_cnt;i++) {
StrPrint(buf,"Seth Task CPU#%d",i);
task=Spawn(&MPCPUTaskInit,NULL,buf,,,SETH_STK,0);
task=Spawn(&APSethInit,NULL,buf,,,SETH_STK,0);
task->rflags=SYS_START_RFLAGS;
//$LK,"CTask",A="MN:CTask"$ allocated off this core's seth_task's heap (Which is Adam)
//$LK,"CTask",A="MN:CTask"$ alloced off this core's seth_task's heap (Which is Adam)
task->task_in_que_signature=TASK_IN_QUE_SIGNATURE_VAL;
CPUStructInit(i,&cpu_structs[i],task);
WBINVD //Not sure why this is needed. Might just need delay.
@@ -379,7 +372,7 @@ U0 MPStart()
mp_cnt=my_mp_cnt; //Finalize cnt
}
U0 MPInit()
U0 BSPInit()
{//Called by adam during start-up
CRAXRBCRCXRDX ee;
CPUId(0x1,&ee);
Kernel/PSect.CPP
+40 -34
View File
@@ -8,46 +8,48 @@ I64 HasLower(U8 *src)
}
CHash *PSectFind(U8 *addr,I64 *_offset)
{//See $LK,"::/Kernel/Hash1a.CPP",A="FL:::/Kernel/Hash1a.CPP,1"$.
{//See $LK,"::/Kernel/KHashA.CPP",A="FL:::/Kernel/KHashA.CPP,1"$.
CHash *result=NULL;
CHashExport *tempex;
Bool has_lower=FALSE;
CHashTable *h=Fs->hash_table;
U64 best=0xFFFF,j;
U64 i,j,best=0xFFFF;
if (!ChkCodePtr(addr)) {
*_offset=best;
return NULL;
}
while (h) {
tempex=h->next_added;
while (tempex!=h) {
j=0;
if (tempex->type&HTT_FUN) {
if (!Bt(&tempex(CHashFun *)->flags,Cf_EXTERN) &&
!Bt(&tempex(CHashFun *)->flags,Ff_INTERNAL))
j=tempex(CHashFun *)->executable_addr;
} else if (tempex->type&HTT_EXPORT_SYS_SYM)
j=tempex->val;
if (j) {
j=addr(I64)-j;
if (0<=j<=best) {
if (tempex->type&HTT_EXPORT_SYS_SYM) {
if (j<best || j==best && !has_lower) {
has_lower=HasLower(tempex->str);
best=j;
result=tempex;
}
} else if (tempex->type&HTT_FUN) {
if (j<best || j==best &&
(result && result->type&HTT_EXPORT_SYS_SYM||!has_lower)) {
has_lower=HasLower(tempex->str);
best=j;
result=tempex;
for (i=0;i<=h->mask;i++) {
tempex=h->body[i];
while (tempex) {
j=0;
if (tempex->type&HTT_FUN) {
if (!Bt(&tempex(CHashFun *)->flags,Cf_EXTERN) &&
!Bt(&tempex(CHashFun *)->flags,Ff_INTERNAL))
j=tempex(CHashFun *)->executable_addr;
} else if (tempex->type&HTT_EXPORT_SYS_SYM)
j=tempex->val;
if (j) {
j=addr(I64)-j;
if (0<=j<=best) {
if (tempex->type&HTT_EXPORT_SYS_SYM) {
if (j<best || j==best && !has_lower) {
has_lower=HasLower(tempex->str);
best=j;
result=tempex;
}
} else if (tempex->type&HTT_FUN) {
if (j<best || j==best &&
(result && result->type&HTT_EXPORT_SYS_SYM||!has_lower)) {
has_lower=HasLower(tempex->str);
best=j;
result=tempex;
}
}
}
}
tempex=tempex->next;
}
tempex=tempex->next_added;
}
h=h->next;
}
@@ -254,7 +256,7 @@ U8 *SrcEdLink(U8 *addr,I64 cnt=1,CTask *mem_task=NULL)
}
Bool PutSrcLink(U8 *addr,I64 cnt=1,U8 *buf=NULL)
{//Put to StdOut a $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT.Z"$ file,line link to src of addr.
{//Put to StdOut a $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ file,line link to src of addr.
U8 *src;
if (src=SrcEdLink(addr,cnt)) {
if (buf)
@@ -268,28 +270,32 @@ Bool PutSrcLink(U8 *addr,I64 cnt=1,U8 *buf=NULL)
return FALSE;
}
U0 E(U8 *addr,I64 cnt=512,I64 edf_dof_flags=0)
Bool E(U8 *addr,I64 cnt=512,I64 edf_dof_flags=0)
{//Edit src at addr.
U8 *st;
Bool result=FALSE;
if (st=SrcEdLink(addr,cnt)) {
if (IsRaw)
EdLiteFileLine(st);
result=EdLiteFileLine(st,edf_dof_flags);
else
Ed(st,edf_dof_flags);
result=Ed(st,edf_dof_flags);
Free(st);
}
return result;
}
U0 Man(U8 *st)
Bool Man(U8 *st,I64 edf_dof_flags=0)
{//Owner's manual for symbol. Edit src code for symbol.
Bool result=FALSE;
U8 **st2;
CHashSrcSym *temph;
if (IsRaw) {
if ((temph=HashFind(st,Fs->hash_table,HTG_SRC_SYM)) && temph->src_link)
EdLiteFileLine(temph->src_link);
result=EdLiteFileLine(temph->src_link,edf_dof_flags);
} else {
st2=MStrPrint("MN:%s",st);
Ed(st2);
result=Ed(st2,edf_dof_flags);
Free(st2);
}
return result;
}
Kernel/Sched.CPP
+10 -7
View File
@@ -1,11 +1,14 @@
/*See $LK,"TempleOS MultiTasking",A="FI:::/Doc/MultiTasking.TXT"$.
Tasks are ordered in a circular queue
by front-to-back window stack order with
the window mgr as the head (paints
the wallpaper). The scheduler is
round-robin. It checks if a task
is ready and runs it or skips it.
On each core, tasks are linked in a
circular doubly-linked list queue with
the Seth task as the head. On core#0,
the queue order represents the front-to-back
window stack order with the window mgr
as the wallpaper.
The scheduler is round-robin. It checks
if a task is ready and runs it or skips it.
Swapping tasks just involves storing and
restoring regs (no disk I/O for virtual
memory and no addr map changes). It is
@@ -35,7 +38,7 @@ The scheduler checks for a few keys:
Each core has its own circular task queue.
For AP processors, they have a "Seth" task
which stays in a loop waiting for jobs or
requests to spawn tasks. See $LK,"MPSethServerTask",A="MN:MPSethServerTask"$().
requests to spawn tasks. See $LK,"APSethTask",A="MN:APSethTask"$().
$HL,1$*/
asm {
Kernel/SrvCmd.CPP
+42 -27
View File
@@ -37,10 +37,9 @@ U0 TaskRstAwaitingMsg(CTask *task=NULL)
}
CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags)
{//Queues a request to compile and execute text.
{//Queues a request to compile and execute src code text.
CSrvCmd *result;
if (!data || !TaskValidate(srv) ||
master && !TaskValidate(master) ||
if (!data || !TaskValidate(srv) || master && !TaskValidate(master) ||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
return NULL;
result=ACAlloc(sizeof(CSrvCmd));
@@ -73,12 +72,11 @@ CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags)
}
CSrvCmd *TaskText(CTask *srv,CTask *master,U8 *data,I64 flags)
{//Post text to servant task. Tell who the master task is.
{//Post StdIn text to servant task. Tell who the master task is.
CSrvCmd *result;
Bool old_preempt=Preempt(OFF);
CTask *task;
if (!data || !TaskValidate(srv) ||
master && !TaskValidate(master) ||
if (!data || !TaskValidate(srv) || master && !TaskValidate(master) ||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT)) {
Preempt(old_preempt);
return NULL;
@@ -126,8 +124,7 @@ CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 msg_code,I64 a1,I64 a2,I64 flags)
//See $LK,"flags",A="MN:SVCf_WAKE_MASTER"$ and $LK,"msg_code",A="MN:MSG_CMD"$.
CSrvCmd *tempc1,*tempc;
CTask *srv=_srv;
if (!TaskValidate(srv) ||
master && !TaskValidate(master)||
if (!TaskValidate(srv) || master && !TaskValidate(master)||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
return NULL;
tempc=ACAlloc(sizeof(CSrvCmd));
@@ -139,8 +136,7 @@ CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 msg_code,I64 a1,I64 a2,I64 flags)
tempc->flags=flags;
PUSHFD
if (Bt(&sys_semas[SYS_SEMA_RECORD_MACRO],0) &&
srv!=sys_macro_util_task &&
msg_code==MSG_KEY_DOWN) {
srv!=sys_macro_util_task && msg_code==MSG_KEY_DOWN) {
tempc1=AMAllocIdentical(tempc);
CLI
QueIns(tempc1,sys_macro_root.last);
@@ -385,17 +381,35 @@ sch_done:
return cnt;
}
I64 SrvUser(U8 *fmt,...)
{//Spawns a visible task and sends text which gets compiled and run.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
I64 result=0;
I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL)
{//Execute code text in PopUp win task.
I64 result;
CSrvCmd *tempc;
CTask *task=Spawn(&SrvUserCmdLine,NULL,"Servant",,Fs);
Fs->popup_task=task;
tempc=TaskExe(task,Fs,buf,1<<SVCf_WAKE_MASTER|1<<SVCf_FOCUS_MASTER);
ScanResult(tempc,&result);
Fs->popup_task=NULL;
Kill(task,FALSE);
Bool old_preempt=Preempt(OFF);
CTask *task=Spawn(&SrvCmdLine,NULL,"Servant",,parent);
if (!parent) {
TaskExe(task,parent,buf,1<<SVCf_EXIT_ON_COMPLETE|1<<SVCf_FREE_ON_COMPLETE);
if (_pu_task) *_pu_task=task;
Preempt(old_preempt);
return 0;
} else {
Fs->popup_task=task;
tempc=TaskExe(task,parent,buf,1<<SVCf_WAKE_MASTER|1<<SVCf_FOCUS_MASTER);
if (_pu_task) *_pu_task=task;
ScanResult(tempc,&result);
Fs->popup_task=NULL;
Kill(task);
if (_pu_task) *_pu_task=NULL;
Preempt(old_preempt);
return result;
}
}
I64 PopUpPrint(U8 *fmt,...)
{//Execute code text in PopUp win task.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
I64 result;
result=PopUp(buf,Fs);
Free(buf);
return result;
}
@@ -445,7 +459,7 @@ U0 XTalk(CTask *task,U8 *fmt,...)
{//Sends text to other task. See $LK,"::/Misc/OSTestSuite.CPP"$.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),*st=AStrNew(buf),
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
TaskText(task,0,st2,0);
TaskText(task,NULL,st2,0);
Free(st2);
Free(buf);
}
@@ -454,7 +468,7 @@ U0 XTalkWait(CTask *task,U8 *fmt,...)
{//Send text to other task and wait for it to idle.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),*st=AStrNew(buf),
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
TaskText(task,0,st2,0);
TaskText(task,NULL,st2,0);
Free(st2);
Free(buf);
TaskWait(task);
@@ -466,19 +480,20 @@ U0 AutoStr(U8 *fmt,...)
if (Bt(&Fs->task_flags,TASKf_INPUT_FILTER_TASK))
ExePrint("%s",buf);
else
TaskText(Fs,0,buf,1<<SVCf_HIGHEST_PRIORITY);
TaskText(Fs,NULL,buf,1<<SVCf_HIGHEST_PRIORITY);
Free(buf);
}
U0 AutoFile(U8 *filename)
{//Send AutoFile code file to self.
U8 *name=DftExt(filename,"AUT.Z");
AutoStr("%F",name);
AutoStr("Cd(\"%C:%s\");;#include \"%s\"",
Drv2Let(Fs->cur_dv),Fs->cur_dir,name);
Free(name);
}
U0 Auto(U8 *fmt,...)
{//Send text to own input buffer. See $LK,"::/Demo/AcctExample/TSDistro.CPP"$.
{//Send text to own input buffer. See $LK,"::/Demo/AcctExample/TOSDistro.CPP"$.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),*st=AStrNew(buf);
AutoStr("\"%%s\",%d;Free(%d);",st,st);
Free(buf);
@@ -487,14 +502,14 @@ U0 Auto(U8 *fmt,...)
U0 XTalkStr(CTask *task,U8 *fmt,...)
{//Send AutoFile code to other task.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
TaskText(task,0,buf,0);
TaskText(task,NULL,buf,0);
Free(buf);
}
U0 XTalkStrWait(CTask *task,U8 *fmt,...)
{//Send AutoFile code to other task and wait for it to idle.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
TaskText(task,0,buf,0);
TaskText(task,NULL,buf,0);
Free(buf);
TaskWait(task);
}
Kernel/Str1a.CPP → Kernel/StrA.CPP
+10 -18
View File
@@ -314,9 +314,8 @@ _extern _STRMATCH U8 *StrMatch(U8 *needle,U8 *haystack_str); //Scan for string i
_extern _STRIMATCH U8 *StrIMatch(U8 *needle,U8 *haystack_str); //Scan for string in string, ignoring case.
_extern _STRCPY U0 StrCpy(U8 *dst,U8 *src); //Copy string.
/*These bitmaps go to 0-511 so that
$LK,"Lex",A="MN:Lex"$() can use them with $LK,"Token Codes",A="MN:TK_EOF"$.
*/
//These bitmaps go to 0-511 so that $LK,"Lex",A="MN:Lex"$() can use them with $LK,"Token Codes",A="MN:TK_EOF"$.
U32 chars_bitmap_alpha[16]=
{0x0000000,0x00000000,0x87FFFFFF,0x07FFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
@@ -334,36 +333,29 @@ chars_bitmap_word[16]=
0,0,0,0,0,0,0,0},
chars_bitmap_filename[16]=
{0x0000000,0x03FF73FB,0xEFFFFFFF,0x2FFFFFFF,0,0,0,0,
{0x0000000,0x03FF73FB,0xEFFFFFFF,0x2FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_dec_numeric[16]=
{0x0000000,0x03FF0000,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x0000000,0x03FF0000,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_hex_numeric[16]=
{0x0000000,0x03FF0000,0x7E,0x7E,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x0000000,0x03FF0000,0x7E,0x7E,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_white_space[16]=
{0x80003600,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x80003600,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_non_eol_white_space[16]=
{0x80001200,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x80001200,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_cr_nl_cursor[16]=
{0x00002421,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x00002421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_tab_ff_cr_nl_cursor[16]=
{0x00003621,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x00003621,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_tab_ff_cr_nl_cursor_dollar[16]=
{0x00003621,0x10,0,0,0,0,0,0,
0,0,0,0,0,0,0,0},
{0x00003621,0x10,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_getkey[16]=
{0x80002600,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
Kernel/Str1b.CPP → Kernel/StrB.CPP
View File
File renamed without changes.
Kernel/StrPrint.CPP
+26 -79
View File
@@ -67,7 +67,7 @@ U8 *MPrintDate(CDate cdt)
U8 *MPrintQ(U8 *ptr,I64 flags)
{
U8 **_buf,*buf,**_dst,*dst;
U8 **_buf,*buf,**_dst,*dst,buf2[8],*ptr2;
I64 ch;
buf=MAlloc(128);
_buf=&buf;
@@ -79,9 +79,9 @@ U8 *MPrintQ(U8 *ptr,I64 flags)
case '$$':
if (flags&SPF_DOLLAR) {
SPutChar(_dst,'\\',_buf);
SPutChar(_dst,'$$'>>6&7+'0',_buf);
SPutChar(_dst,'$$'>>3&7+'0',_buf);
SPutChar(_dst,'$$'&7+'0',_buf);
SPutChar(_dst,'x',_buf);
SPutChar(_dst,'2',_buf);
SPutChar(_dst,'4',_buf);
} else {
SPutChar(_dst,ch,_buf);
SPutChar(_dst,ch,_buf);
@@ -110,13 +110,13 @@ U8 *MPrintQ(U8 *ptr,I64 flags)
SPutChar(_dst,ch,_buf);
break;
default:
if (CH_SHIFT_SPACE<=ch<=0x7F) {
if (ch>=CH_SHIFT_SPACE && ch!=0x7F)
SPutChar(_dst,ch,_buf);
} else {
SPutChar(_dst,'\\',_buf);
SPutChar(_dst,ch>>6&7+'0',_buf);
SPutChar(_dst,ch>>3&7+'0',_buf);
SPutChar(_dst,ch&7+'0',_buf);
else {
StrPrint(buf2,"\\x%02X",ch);
ptr2=buf2;
while (*ptr2)
SPutChar(_dst,*ptr2++,_buf);
}
}
}
@@ -160,56 +160,27 @@ U8 *MPrintq(U8 *ptr,I64 flags)
case 't':
SPutChar(_dst,'\t',_buf);
break;
case '0':
SPutChar(_dst,0,_buf);
break;
sub_switch_end:
ptr++;
break;
sub_switch_start:
case 'x':
case 'X':
i=0;
ptr++;
while (TRUE) {
ch1=ToUpper(*ptr++);
if (Bt(chars_bitmap_hex_numeric,ch1)) {
if (ch1<='9')
i=i<<4+ch1-'0';
else
i=i<<4+ch1-'A'+10;
} else
break;
}
break;
case 'b':
case 'B':
i=0;
ptr++;
while (TRUE) {
ch1=*ptr++;
if ('0'<=ch1<='1')
i=i<<1+ch1-'0';
case 'x':
case 'X':
i=0;
ptr++;
while (TRUE) {
ch1=ToUpper(*ptr++);
if (Bt(chars_bitmap_hex_numeric,ch1)) {
if (ch1<='9')
i=i<<4+ch1-'0';
else
break;
}
break;
case 'o':
case 'O':
i=0;
ptr++;
goto sq_octal;
case '0'...'7':
i=ch1-'0';
ptr++;
sq_octal:
while (TRUE) {
ch1=*ptr++;
if ('0'<=ch1<='7')
i=i<<3+ch1-'0';
else
break;
}
break;
sub_switch_end:
i=i<<4+ch1-'A'+10;
} else
break;
}
SPutChar(_dst,i,_buf);
ptr--;
break;
@@ -897,30 +868,6 @@ sp_out_eng: //Engineering notation
} while (m && k<TEMP_BUF_LEN-SLOP);
goto sp_out_num;
}
case 'o':
case 'O':
if (cur_arg>=argc)
throw('StrPrint');
m=argv[cur_arg++];
if (flags&SPF_COMMA) {
comma_fmt_cnt=comma_cnt=3;
do {
temp_buf[k++]= m&7 +'0';
m>>=3;
if (!m) break;
if (!--comma_cnt) {
temp_buf[k++]=',';
comma_cnt=3;
}
} while (k<TEMP_BUF_LEN-SLOP);
goto sp_out_comma_num;
} else {
do {
temp_buf[k++]= m&7 +'0';
m>>=3;
} while (m && k<TEMP_BUF_LEN-SLOP);
goto sp_out_num;
}
case '%':
SPutChar(_dst,'%',_buf);
break;
Kernel/StrScan.CPP
+1 -2
View File
@@ -25,7 +25,6 @@ I64 Str2I64(U8 *st,I64 radix=10,U8 **_end_ptr=NULL)
if (ch>='B' && (radix<=10 || ch>'A'+radix-11))
switch (ch) {
case 'B': radix=2; st++; break;
case 'O': radix=8; st++; break;
case 'D': radix=10; st++; break;
case 'X': radix=16; st++; break;
}
@@ -141,7 +140,7 @@ CDate Str2Date(U8 *_src)
It also supports some funs
SM() start of mon
EM() end of mon
SM() start of year
SY() start of year
EY() end of year
Full expressions are not implimented
but you can do stuff like SM(*-7)+3
Kernel/Task1a.CPP → Kernel/Task.CPP
+27 -41
View File
@@ -25,30 +25,25 @@ Bool TaskValidate(CTask *task)
return TRUE;
}
U0 Kill(CTask *task,Bool wait=TRUE)
Bool Kill(CTask *task,Bool wait=TRUE)
{//Terminate other task.
I64 i;
CCPU *c;
Bool found,old_preempt=Preempt(OFF);
if (TaskValidate(task)) {
if (task==sys_winmgr_task)
found=TRUE;
else
found=FALSE;
for (i=0;i<mp_cnt;i++) {
c=&cpu_structs[i];
if (task==c->seth_task)
found=TRUE;
}
if (!found) {
LBts(&task->task_flags,TASKf_KILL_TASK);
if (wait) {
do Yield;
while (TaskValidate(task) && Bt(&task->task_flags,TASKf_KILL_TASK));
}
Bool old_preempt=Preempt(OFF);
if (TaskValidate(task) && task!=sys_winmgr_task) {
for (i=0;i<mp_cnt;i++)
if (task==cpu_structs[i].seth_task)
goto kl_fail;
LBts(&task->task_flags,TASKf_KILL_TASK);
if (wait) {
do Yield;
while (TaskValidate(task) && Bt(&task->task_flags,TASKf_KILL_TASK));
}
Preempt(old_preempt);
return TRUE;
}
kl_fail:
Preempt(old_preempt);
return FALSE;
}
Bool Suspend(CTask *task=NULL,Bool state=TRUE)
@@ -86,6 +81,7 @@ CTaskStk *TaskStkNew(I64 stk_size,CTask *task)
#exe {OptOn(OPTf_NO_REG_VAR);};
argpop I64 CallStkGrow(I64 stk_size_threshold,I64 stk_size,/*argpop*/I64 (*fp_addr)(...),...)
{//Grow stk in call with any fixed num of args.
//See $LK,"::/Demo/StkGrow.CPP"$.
CTaskStk *temps,*temps2,**_stk;
I64 result,*rsp,*rsp2,*old_stk;
@@ -183,22 +179,10 @@ I64 TaskInit(CTask *task,I64 stk_size)
task->fpu_mmx=MAllocAligned(sizeof(CFPU),0x10,task);
MemCpy(task->fpu_mmx,SYS_FIXED_AREA+offset(CSysFixedArea.init_fpu_mmx),sizeof(CFPU));
if (task==SYS_FIXED_AREA+offset(CSysFixedArea.adam)) {
// Delayed until heap expanded. See $LK,"Expand Heap",A="FA:::/Kernel/Mem1a.CPP,ExpandHeap"$
// task->hash_table=HashTableNew(ADAM_HASH_SIZE,task);
} else {
if (!Gs->num)
task->hash_table=HashTableNew(STD_HASH_SIZE,task);
else
task->hash_table=HashTableNew(MP_STD_HASH_SIZE,task);
}
task->hash_table=HashTableNew(TASK_HASH_SIZE,task);
if (!stk_size) {
if (!Gs->num)
stk_size=DFT_STK;
else
stk_size=MP_DFT_STK;
}
if (!stk_size)
stk_size=DFT_STK;
task->stk=temps=TaskStkNew(stk_size,task);
task->rsp=(&temps->stk_base)(U8 *)+temps->stk_size;
@@ -211,9 +195,11 @@ I64 TaskInit(CTask *task,I64 stk_size)
task->win_top =13;
task->win_bottom =text.rows-2;
//Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$ gets NULL. Okay, I guess, until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
task->cur_prt=dsk.drv_to_prt[ToUpper(*sys_acct)-'A'];
task->cur_dir=StrNew(sys_acct+2,task);
if (dsk.boot_drv_let) //Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$. Okay, I guess, until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
task->cur_dv=dsk.let_to_drv[ToUpper(dsk.boot_drv_let)-'A'];
task->cur_dir=StrNew("/Home",task);
Seed(,task);
return task;
}
@@ -226,7 +212,7 @@ CTask *Spawn(U0 (*fp_start_addr)(U8 *data),U8 *data=NULL,
I64 flags=1<<SVCf_ADD_TO_QUE)
{//Create task on core running at address.
//Alloc $LK,"CTask",A="MN:CTask"$ structure from code heap so addr will be short.
//Could be allocated off of data heap.
//Could be alloced off of data heap.
CTask *task;
if (target_cpu>=0)
return SpawnQue(fp_start_addr,data,task_name,target_cpu,parent,stk_size,flags);
@@ -375,7 +361,7 @@ U0 UserCmdLine(I64 dummy=0)
UserTaskCont;
}
CTask *SpawnUser(U8 *fmt=NULL,...)
CTask *User(U8 *fmt=NULL,...)
{//Create user term task.
U8 *st;
CTask *task=Spawn(&UserCmdLine);
@@ -401,7 +387,7 @@ U0 SrvTaskCont()
}
}
U0 SrvUserCmdLine(I64 dummy=0)
U0 SrvCmdLine(I64 dummy=0)
{
nounusedwarn dummy;
Fs->win_inhibit=WIG_USER_TASK_DFT;
@@ -440,7 +426,7 @@ I64 TaskEnd()
return task->parent_task;
}
PrtsRelease;
DrvsRelease;
BlkDevsRelease;
tempt1=(&task->next_child_task)(U8 *)-offset(CTask.next_sibling_task);
tempt=tempt1->next_sibling_task;