By "allowed" I'm assuming you are wanting gpl code added to those projects to use the closed source wrapper but not code added to dosbox that is not GPL. Main problem is due to dosbox changes ensuring that nothing broke with the wrapper would be difficult......same as with forks that use glide wrappers.

Official dosbox doesn't use any wrappers for the main reason that the maintenance burden is too high for too little gain for a small number of dos games.

https://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs

The license allows it so likely best case for now is fork the code, assuming that the games you support work except for the required wrapper then if the patch is minimal it probably wouldn't be too much of a burden to maintain the fork. It may not be ideal but at least there would be something there for someone in the future to work on something more open source friendly.

DosFreak wrote on 2023-12-01, 11:49:

By "allowed" I'm assuming you are wanting gpl code added to those projects to use the closed source wrapper but not code added t […]
Show full quote

By "allowed" I'm assuming you are wanting gpl code added to those projects to use the closed source wrapper but not code added to dosbox that is not GPL. Main problem is due to dosbox changes ensuring that nothing broke with the wrapper would be difficult......same as with forks that use glide wrappers.

Official dosbox doesn't use any wrappers for the main reason that the maintenance burden is too high for too little gain for a small number of dos games.

https://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs

The license allows it so likely best case for now is fork the code, assuming that the games you support work except for the required wrapper then if the patch is nimal it probably wouldn't be too much of a burden to maintain the fork.

Thanks @DosFreak. That's what I was hoping for. I'll fork the code.

Hi

Sorry guys. I realise you have other things to deal with but,

I've got a slight problem with heavy debug. I modified it to dump all instructions irrespective of breakpoints by modifying DEBUG_HeavyLogInstruction to store all instructions in a vector and DEBUG_HeavyIsBreakpoint to log them.

The problem is I get dumps like this (registers info. truncated):

105DB:0000030C  call 00000C0D($ + 8fe)                                  
205DB : 0000030C  call 00000C0D($ + 8fe)                                
305DB : 00000C22  repe cmpsw                                            
405DB : 00000C24  pop  di                                               
505DB : 0000030F  mov[0035], cl                  ds : [00000035] = 8003 
605DB : 0000030F  mov[0035], cl                  ds : [00000035] = 8003 
705DB : 00002824  mov[0D66], gs                  ds : [00000D66] = 0000 
805DB : 00002824  mov[0D66], gs                  ds : [00000D66] = 0000 
905DB : 0000283F  cmp  byte[11F0], 00             ds: [000011F0] = 0000 
1005DB : 0000283F  cmp  byte[11F0], 00             ds: [000011F0] = 0000 
1105DB : 000008CA  mov  al, 0F                                           
1205DB : 000008CA  mov  al, 0F                                           
1305DB : 0000031A  smsw ax                                               
1405DB : 0000031A  smsw ax                                               
1505DB : 0000031A  smsw ax                                               
1605DB : 0000031D or al, 01                                             

The duplicate instructions I get, sometimes DEBUG_HeavyIsBreakpoint is called multiple times for a single instruction.

What I don't get is EIP jumping around like crazy:

105DB : 0000283F  cmp  byte[11F0], 00             ds: [000011F0] = 0000 
205DB : 000008CA  mov  al, 0F  

Sorry about my code. I'm still playing around with it.

I thought it was a problem with my added code, but can't be sure. the new bit is this
fullLog.push_back(inst); (fullLog is a std::vector)
:

1void DEBUG_HeavyLogInstruction(void) {
2
3	static char empty[23] = { 32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,0 };
4
5	PhysPt start = GetAddress(SegValue(cs),reg_eip);
6	char dline[200];
7	DasmI386(dline, start, reg_eip, cpu.code.big);
8	char* res = empty;
9	if (showExtend) {
10		res = AnalyzeInstruction(dline,false);
11		if (!res || !(*res)) res = empty;
12		Bitu reslen = strlen(res);
13		if (reslen < 22) memset(res + reslen, ' ',22 - reslen);
14		res[22] = 0;
15	};
16
17	Bitu len = strlen(dline);
18	if (len < 30) memset(dline + len,' ',30 - len);
19	dline[30] = 0;
20
21	TLogInst & inst = logInst[logCount];
22	strcpy(inst.dline,dline);
23	inst.s_cs = SegValue(cs);
24	inst.eip  = reg_eip;
25	strcpy(inst.res,res);
26	inst.eax  = reg_eax;
27	inst.ebx  = reg_ebx;
28	inst.ecx  = reg_ecx;
29	inst.edx  = reg_edx;
30	inst.esi  = reg_esi;
31	inst.edi  = reg_edi;
32	inst.ebp  = reg_ebp;
33	inst.esp  = reg_esp;
34	inst.s_ds = SegValue(ds);
35	inst.s_es = SegValue(es);
36	inst.s_fs = SegValue(fs);
37	inst.s_gs = SegValue(gs);
38	inst.s_ss = SegValue(ss);
39	inst.c    = get_CF()>0;
40	inst.z    = get_ZF()>0;
41	inst.s    = get_SF()>0;
42	inst.o    = get_OF()>0;
43	inst.a    = get_AF()>0;
44	inst.p    = get_PF()>0;
45	inst.i    = GETFLAGBOOL(IF);
46	fullLog.push_back(inst);
47
48	if (++logCount >= LOGCPUMAX) logCount = 0;
49};

The new bits here are
//if (logHeavy)
DEBUG_HeavyLogInstruction();
#if LOG_TO_FILE
if(fullLog.size() > 2000)
DEBUG_HeavyWriteLogInstructionRendition();
#endif
:

1bool DEBUG_HeavyIsBreakpoint(void) {
2	static Bitu zero_count = 0;
3
4	if (cpuLog) {
5		if (cpuLogCounter>0) {
6			LogInstruction(SegValue(cs),reg_eip,cpuLogFile);
7			cpuLogCounter--;
8		}
9		if (cpuLogCounter<=0) {
10			cpuLogFile.flush();
11			cpuLogFile.close();
12			DEBUG_ShowMsg("DEBUG: cpu log LOGCPU.TXT created\n");
13			cpuLog = false;
14			DEBUG_EnableDebugger();
15			return true;
16		}
17	}
18
19	// LogInstruction
20	//if (logHeavy)
21		DEBUG_HeavyLogInstruction();
22#if LOG_TO_FILE
23		if(fullLog.size() > 2000)
24			DEBUG_HeavyWriteLogInstructionRendition();
25#endif
26
27and the logging function which dumps all instructions is  (out is a global std::ofstream):
28
29[code]void DEBUG_HeavyWriteLogInstructionRendition(void) {
30	//if (!logHeavy) return;
31	//logHeavy = false;
32
33	//DEBUG_ShowMsg("DEBUG: writing Rendition Dump.TXT, num %u\n", fullLog.size());
34
35	//ofstream out("LOGCPU_INT_CD.TXT");
36	if (!out.is_open()) {
37		DEBUG_ShowMsg("DEBUG: Failed.\n");
38		return;
39	}
40	out << hex << noshowbase << setfill('0') << uppercase;
41	//Bit32u startLog = logCount;
42	//do {
43	for (auto &inst : fullLog) {
44		// Write Instructions
45		//TLogInst& inst = logInst[startLog];
46		out << setw(4) << inst.s_cs << ":" << setw(8) << inst.eip << "  "
47			<< inst.dline << "  " << inst.res << " EAX:" << setw(8) << inst.eax
48			<< " EBX:" << setw(8) << inst.ebx << " ECX:" << setw(8) << inst.ecx
49			<< " EDX:" << setw(8) << inst.edx << " ESI:" << setw(8) << inst.esi
50			<< " EDI:" << setw(8) << inst.edi << " EBP:" << setw(8) << inst.ebp
51			<< " ESP:" << setw(8) << inst.esp << " DS:" << setw(4) << inst.s_ds
52			<< " ES:" << setw(4) << inst.s_es << " FS:" << setw(4) << inst.s_fs
53			<< " GS:" << setw(4) << inst.s_gs << " SS:" << setw(4) << inst.s_ss
54			<< " CF:" << inst.c << " ZF:" << inst.z << " SF:" << inst.s
55			<< " OF:" << inst.o << " AF:" << inst.a << " PF:" << inst.p
56			<< " IF:" << inst.i << endl;
57
58		/*		fprintf(f,"%04X:%08X   %s  %s  EAX:%08X EBX:%08X ECX:%08X EDX:%08X ESI:%08X EDI:%08X EBP:%08X ESP:%08X DS:%04X ES:%04X FS:%04X GS:%04X SS:%04X CF:%01X ZF:%01X SF:%01X OF:%01X AF:%01X PF:%01X IF:%01X\n",
59					logInst[startLog].s_cs,logInst[startLog].eip,logInst[startLog].dline,logInst[startLog].res,logInst[startLog].eax,logInst[startLog].ebx,logInst[startLog].ecx,logInst[startLog].edx,logInst[startLog].esi,logInst[startLog].edi,logInst[startLog].ebp,logInst[startLog].esp,
60						logInst[startLog].s_ds,logInst[startLog].s_es,logInst[startLog].s_fs,logInst[startLog].s_gs,logInst[startLog].s_ss,

61						logInst[startLog].c,logInst[startLog].z,logInst[startLog].s,logInst[startLog].o,logInst[startLog].a,logInst[startLog].p,logInst[startLog].i);*/
62						//if (++startLog >= LOGCPUMAX) startLog = 0;
63					//} while (startLog != logCount);
64	}
65	fullLog.clear();
66	//out.close();
67	//DEBUG_ShowMsg("DEBUG: Done.\n");
68};
69
70//#endif
71	if (zeroProtect) {
72		Bit32u value = 0;
73		if (!mem_readd_checked(SegPhys(cs)+reg_eip,&value)) {
74			if (value == 0) zero_count++;
75			else zero_count = 0;
76		}
77		if (GCC_UNLIKELY(zero_count == 10)) E_Exit("running zeroed code");
78	}
79
80	if (skipFirstInstruction) {
81		skipFirstInstruction = false;
82		return false;
83	}
84	if (!CBreakpoint::BPoints.empty() && CBreakpoint::CheckBreakpoint(SegValue(cs),reg_eip)) {
85		return true;
86	}
87	return false;
88}

The only other thing I've modified is the INT 10h call, to support function (AX=0x158D).

Make sure you are using the core=normal setting, as the instruction pointer skipping around could be due to the dynamic core that executes blocks of instructions where the debugger can only be active between blocks.

ripsaw8080 wrote on 2023-12-06, 07:26:

Make sure you are using the core=normal setting, as the instruction pointer skipping around could be due to the dynamic core that executes blocks of instructions where the debugger can only be active between blocks.

Thanks @RipSaw8080!

That did the trick.

Another quick question:

This:

1mem_writed(0xF00009FC, 0x00000079);

produces an illegal write error in the console.

I think that's a video BIOS address.

1static INLINE void mem_writed_inline(PhysPt address,Bit32u val) {
2	if ((address & 0xfff)<0xffd) {
3		HostPt tlb_addr=get_tlb_write(address);
4		if (tlb_addr) host_writed(tlb_addr+address,val);
5		else (get_tlb_writehandler(address))->writed(address,val);
6	} else mem_unalignedwrited(address,val);
7}

Would I have to check the address and return address specific values in mem_readd?

FYI, segment 0xF000 is the system BIOS region, segment 0xC000 is the video BIOS region (for EGA/VGA).

Use phys_write to write to BIOS (read-only) regions, because mem_write cannot.

Perhaps this was your intent:

1phys_writed(PhysMake(0xF000, 0x09FC), 0x00000079);

ripsaw8080 wrote on 2023-12-10, 00:40:

FYI, segment 0xF000 is the system BIOS region, segment 0xC000 is the video BIOS region (for EGA/VGA). […]
Show full quote

FYI, segment 0xF000 is the system BIOS region, segment 0xC000 is the video BIOS region (for EGA/VGA).

Use phys_write to write to BIOS (read-only) regions, because mem_write cannot.

Perhaps this was your intent:

Copy code to clipboard

1phys_writed(PhysMake(0xF000, 0x09FC), 0x00000079);

Yup that's what I needed. The code reads mem address f00009fc and compares a 32 bit value there . I don't know what that value represents. The value there is Anded (test), checked for less than, on fail compared to 79h.

Need to see what a actual rendition setup returns.

The address 0x9fc with segment 0000 is returned in a video rom bios call int 10h ax=158dh on physical hardware . I *think* this is rendition specific. The net suggests this returns display adapter parameters, but doesn't list anything specific. The segment is offset with 0xf000.

ripsaw8080 wrote on 2023-12-10, 00:40:

Perhaps this was your intent: […]
Show full quote

Perhaps this was your intent:

Copy code to clipboard

1phys_writed(PhysMake(0xF000, 0x09FC), 0x00000079);

Doesn't this produce 0xF09FC as the address?

1static INLINE PhysPt PhysMake(Bit16u seg,Bit16u off) {
2	return (seg<<4)+off;
3}

Also there was a bug with my Turbo C code in that it didn't correctly preserve registers.

It appears to return

1CX=some fixed address dependent on the card
2DX=C000

On further analysis the actual address games use are:
0x000C0A2C (for a Rendition V2200 reference bios) (Once I get feedback from an actual V1000 board with the new test app, I expect to get CX=0x9FC and DX=C000)

vQuake appears to add 0xF0000000
for an address of 0xF00C0A2C
and Rendition DMATest uses
0x000C0A2C

So PhysMake should be correct. But this isn't the video BIOS. It keeps incrementing the address until it encounters 0x79. If it doesn't it just keeps going.

The V2200 reference BIOS indicates that the address (0xC0000A2C) contains 3 bytes, "Rendition Reference Board", more bytes followed by 'y' (0x79).

V1000 bios indicates that the address (0xC00009FC) contains a chunk of bytes, "PCIRc", more bytes, "Rendition Reference board", more bytes and then 'y'.

[EDIT] It also appears to count how many bytes into the block it took to encounter byte 0x79.

Unless I'm missing something , 0x000C0000 isn't the video bios [EDIT2](unless maybe in real mode).

Video BIOS is at C000:0000, linear address 0xC00000. My example with PhysMake was based on real mode segment and offset for the system BIOS. Perhaps the apps you are looking at use protected mode, and thus reference 32-bit offsets within a descriptor.

vQuake and the DMA Test use Dos4GW .

The disassembly appears to show register access to eax, ebx and so on, which I think indicates protected mode.

I *don't* know. x86 assembler was never my forte. I did dabble with VESA BIOS extensions with Turbo C and direct writes to video RAM. I no longer have the source for any of that, though I do have some leftover binaries.

Maybe there's an allocated structure at C0A2C.

But setting the uppermost 32 bit nibble to 0xF should be the system BIOS, unless I'm missing something.

[EDIT] Oops! That should be linear 0x00F00000, not 0xF000000. I've never done any DOS protected mode x86 stuff.

BIOS calls aren't accessible in protected mode because, the CPU boots up in real mode and the BIOS is written to support that.

Could this be a side effect of paging? Not entirely sure what DOS4GW does.

Alternatively could you recommended a decent book on DOS protected mode coding?

[EDIT] There's no video BIOS access on Win32 and I have no idea how memory mapping/paging works on x86.

[EDIT] https://en.wikibooks.org/wiki/X86_Assembly/Protected_Mode seems to help. I have noticed CR<n> references in there.

[EDIT3] I see a lot of lldt and smsw.

sharangad wrote on 2024-01-06, 10:36:

Alternatively could you recommended a decent book on DOS protected mode coding?

https://www.amazon.com/Dos-Windows-Protected- … g/dp/0201632187 Seems like a good book

Thanks xcomcmdr.

Does DOsbox prevent reads from the video BIOS?

For instance:

1lea  ebx,[edx+eax]              [illegal]              EAX:000C0000 EBX:001CB3A4 ECX:00000000 EDX:00000A2C

where EAX + EDX = 0xC0A2C is in video ram doesn't seem to produce what's at the location.

LEA calculates an address and doesn't access memory.

My bad. I mistook the square brackets for an indirection.