VOID
tracet(
CMD_ARGLIST
)
/*++
Routine Description:
This routine dumps LDT selectors. The selectors are dumped from the
user mode Ldt, rather than the system ldt.
Arguments:
CurrentProcess -- Supplies a handle to the process to dump selectors for
CurrentThread -- Supplies a handle to the thread to dump selectors for
ArgumentString -- Supplies the arguments to the !sel command
Return Value
None.
--*/
{
PVOID pMem;
BOOL bTrace;
CMD_INIT();
if (!ReadMemExpression("ntvdm!bDpmiTraceOn", &bTrace, 4)) {
return;
}
pMem = (PVOID)EXPRESSION("ntvdm!bDpmiTraceOn");
if (!pMem) {
PRINTF("DPMI trace history not available\n");
return;
}
if (!READMEM(pMem, &bTrace, 4)) {
PRINTF("Error reading memory\n");
return;
}
if (!bTrace) {
int Count = 0;
bTrace = 1;
WRITEMEM(pMem, &bTrace, 4);
pMem = (PVOID)EXPRESSION("ntvdm!bDpmiTraceCount");
WRITEMEM(pMem, &Count, 4);
PRINTF("Trace is now on and reset\n");
} else {
bTrace = 0;
WRITEMEM(&pMem, &bTrace, 4);
PRINTF("Trace is now off\n");
}
}
static int
encode_cb_recall(struct xdr_stream *xdr, struct nfs4_cb_recall *cb_rec)
{
__be32 *p;
int len = cb_rec->cbr_fhlen;
RESERVE_SPACE(12+sizeof(cb_rec->cbr_stateid) + len);
WRITE32(OP_CB_RECALL);
WRITEMEM(&cb_rec->cbr_stateid, sizeof(stateid_t));
WRITE32(cb_rec->cbr_trunc);
WRITE32(len);
WRITEMEM(cb_rec->cbr_fhval, len);
return 0;
}
VOID
DisableBreakPoint(
VDM_BREAKPOINT *pBP
)
{
int mode;
ULONG lpAddress;
BYTE byte;
if (!(pBP->Flags & VDMBP_ENABLED)) {
return;
}
if (pBP->Flags & VDMBP_V86) {
mode = V86_MODE;
} else {
mode = PROT_MODE;
}
lpAddress = GetInfoFromSelector(pBP->Seg, mode, NULL) + GetIntelBase() + pBP->Offset;
if (READMEM((PVOID)lpAddress, &byte, 1)) {
if (byte == 0xcc) {
PRINTF("Writing %02X to %08X\n", pBP->Opcode, lpAddress);
WRITEMEM((PVOID)lpAddress, &pBP->Opcode, 1);
}
}
pBP->Flags &= ~VDMBP_ENABLED;
}
static void
encode_cb_recall(struct xdr_stream *xdr, struct nfs4_delegation *dp,
struct nfs4_cb_compound_hdr *hdr)
{
__be32 *p;
int len = dp->dl_fh.fh_size;
RESERVE_SPACE(12+sizeof(dp->dl_stateid) + len);
WRITE32(OP_CB_RECALL);
WRITE32(dp->dl_stateid.si_generation);
WRITEMEM(&dp->dl_stateid.si_opaque, sizeof(stateid_opaque_t));
WRITE32(0); /* truncate optimization not implemented */
WRITE32(len);
WRITEMEM(&dp->dl_fh.fh_base, len);
hdr->nops++;
}
/** Fills a serverinfo packet with information about wad files loaded.
*
* \todo Give this function a better name since it is in global scope.
* Used to have size limiting built in - now handed via W_LoadWadFile in w_wad.c
*
*/
UINT8 *PutFileNeeded(void)
{
size_t i, count = 0;
UINT8 *p = netbuffer->u.serverinfo.fileneeded;
char wadfilename[MAX_WADPATH] = "";
UINT8 filestatus;
for (i = 0; i < numwadfiles; i++)
{
// If it has only music/sound lumps, don't put it in the list
if (!wadfiles[i]->important)
continue;
filestatus = 1; // Importance - not really used any more, holds 1 by default for backwards compat with MS
// Store in the upper four bits
if (!cv_downloading.value)
filestatus += (2 << 4); // Won't send
else if ((wadfiles[i]->filesize <= (UINT32)cv_maxsend.value * 1024))
filestatus += (1 << 4); // Will send if requested
// else
// filestatus += (0 << 4); -- Won't send, too big
WRITEUINT8(p, filestatus);
count++;
WRITEUINT32(p, wadfiles[i]->filesize);
nameonly(strcpy(wadfilename, wadfiles[i]->filename));
WRITESTRINGN(p, wadfilename, MAX_WADPATH);
WRITEMEM(p, wadfiles[i]->md5sum, 16);
}
netbuffer->u.serverinfo.fileneedednum = (UINT8)count;
return p;
}
static void
encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
{
__be32 *p;
RESERVE_SPACE(sizeof(stateid_t));
WRITE32(sid->si_generation);
WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
}
static void
encode_cb_recall(struct xdr_stream *xdr, struct nfs4_delegation *dp,
struct nfs4_cb_compound_hdr *hdr)
{
__be32 *p;
int len = dp->dl_fh.fh_size;
RESERVE_SPACE(4);
WRITE32(OP_CB_RECALL);
encode_stateid(xdr, &dp->dl_stateid);
RESERVE_SPACE(8 + (XDR_QUADLEN(len) << 2));
WRITE32(0); /* truncate optimization not implemented */
WRITE32(len);
WRITEMEM(&dp->dl_fh.fh_base, len);
hdr->nops++;
}
/** Fills a serverinfo packet with information about wad files loaded.
*
* \todo Give this function a better name since it is in global scope.
*
*/
UINT8 *PutFileNeeded(void)
{
size_t i, count = 0;
UINT8 *p = netbuffer->u.serverinfo.fileneeded;
char wadfilename[MAX_WADPATH] = "";
UINT8 filestatus;
size_t bytesused = 0;
for (i = 0; i < numwadfiles; i++)
{
// If it has only music/sound lumps, mark it as unimportant
if (W_VerifyNMUSlumps(wadfiles[i]->filename))
filestatus = 0;
else
filestatus = 1; // Important
// Store in the upper four bits
if (!cv_downloading.value)
filestatus += (2 << 4); // Won't send
else if ((wadfiles[i]->filesize > (UINT32)cv_maxsend.value * 1024))
filestatus += (0 << 4); // Won't send
else
filestatus += (1 << 4); // Will send if requested
bytesused += (nameonlylength(wadfilename) + 22);
// Don't write too far...
if (bytesused > sizeof(netbuffer->u.serverinfo.fileneeded))
I_Error("Too many wad files added to host a game. (%s, stopped on %s)\n", sizeu1(bytesused), wadfilename);
WRITEUINT8(p, filestatus);
count++;
WRITEUINT32(p, wadfiles[i]->filesize);
nameonly(strcpy(wadfilename, wadfiles[i]->filename));
WRITESTRINGN(p, wadfilename, MAX_WADPATH);
WRITEMEM(p, wadfiles[i]->md5sum, 16);
}
netbuffer->u.serverinfo.fileneedednum = (UINT8)count;
return p;
}
static void
encode_cb_sequence(struct xdr_stream *xdr, struct nfsd4_cb_sequence *args,
struct nfs4_cb_compound_hdr *hdr)
{
__be32 *p;
if (hdr->minorversion == 0)
return;
RESERVE_SPACE(1 + NFS4_MAX_SESSIONID_LEN + 20);
WRITE32(OP_CB_SEQUENCE);
WRITEMEM(args->cbs_clp->cl_sessionid.data, NFS4_MAX_SESSIONID_LEN);
WRITE32(args->cbs_clp->cl_cb_seq_nr);
WRITE32(0); /* slotid, always 0 */
WRITE32(0); /* highest slotid always 0 */
WRITE32(0); /* cachethis always 0 */
WRITE32(0); /* FIXME: support referring_call_lists */
hdr->nops++;
}
VOID
EnableBreakPoint(
VDM_BREAKPOINT *pBP
)
{
int mode;
ULONG lpAddress;
BYTE byte;
if (pBP->Flags & VDMBP_ENABLED) {
return;
}
if (pBP->Flags & VDMBP_V86) {
mode = V86_MODE;
} else {
mode = PROT_MODE;
}
lpAddress = GetInfoFromSelector(pBP->Seg, mode, NULL) + GetIntelBase() + pBP->Offset;
if (READMEM((PVOID)lpAddress, &byte, 1)) {
if (byte != 0xcc) {
static BYTE bpOp = 0xcc;
PRINTF("Writing %02X to %08X\n", bpOp, lpAddress);
WRITEMEM((PVOID)lpAddress, &bpOp, 1);
pBP->Opcode = byte;
}
} else {
PRINTF("Error enabling breakpoint at %04X:%08X\n", pBP->Seg, pBP->Offset);
return;
}
pBP->Flags |= VDMBP_ENABLED;
}
VOID
UpdateBreakPoint(
int Cmd
)
{
ULONG lpAddress;
VDM_BREAKPOINT VdmBreakPoint;
int BPNum;
lpAddress = (*GetExpression)("ntvdm!VdmBreakPoints");
if (!lpAddress) {
PRINTF("Could not find symbol ntvdm!VdmBreakPoints\n");
return;
}
if (!GetNextToken()) {
PRINTF("Please specify an breakpoint #\n");
return;
}
sscanf(lpArgumentString, "%d", &BPNum);
if (BPNum > MAX_VDM_BREAKPOINTS) {
PRINTF("Invalid breakpoint - %d\n", BPNum);
}
lpAddress += BPNum*sizeof(VDM_BREAKPOINT);
if (!READMEM((PVOID)lpAddress, &VdmBreakPoint, sizeof(VDM_BREAKPOINT))) {
PRINTF("Error reading BP memory\n");
return;
}
switch(Cmd) {
case 1: // CLEAR
if (VdmBreakPoint.Flags & VDMBP_SET) {
if (VdmBreakPoint.Flags & VDMBP_ENABLED) {
DisableBreakPoint(&VdmBreakPoint);
}
VdmBreakPoint.Flags &= ~VDMBP_SET;
}
break;
case 2: // DISABLE
if (VdmBreakPoint.Flags & VDMBP_SET) {
if (VdmBreakPoint.Flags & VDMBP_ENABLED) {
DisableBreakPoint(&VdmBreakPoint);
}
}
break;
case 3: // ENABLE
if (VdmBreakPoint.Flags & VDMBP_SET) {
if (!(VdmBreakPoint.Flags & VDMBP_ENABLED)) {
EnableBreakPoint(&VdmBreakPoint);
}
}
break;
}
WRITEMEM((PVOID)lpAddress, &VdmBreakPoint, sizeof(VDM_BREAKPOINT));
}
VOID
bp(
CMD_ARGLIST
)
{
ULONG lpAddress, lpTmp;
VDM_BREAKPOINT VdmBreakPoint;
int BPNum;
VDMCONTEXT ThreadContext;
WORD selector;
ULONG offset;
USHORT count = 1;
int mode;
USHORT flags = 0;
CMD_INIT();
lpAddress = (*GetExpression)("ntvdm!VdmBreakPoints");
if (!lpAddress) {
PRINTF("Could not find symbol ntvdm!VdmBreakPoints\n");
return;
}
mode = GetContext( &ThreadContext );
if (!GetNextToken()) {
PRINTF("Please enter an address\n");
return;
}
if (!ParseIntelAddress(&mode, &selector, &offset)) {
return;
}
if (mode == V86_MODE) {
flags = VDMBP_V86;
}
//
// first see if it's set already
//
for (lpTmp = lpAddress, BPNum = 0; BPNum < MAX_VDM_BREAKPOINTS;
BPNum++, lpTmp+=sizeof(VDM_BREAKPOINT)) {
if (!READMEM((PVOID)lpTmp, &VdmBreakPoint, sizeof(VDM_BREAKPOINT))) {
PRINTF("Error reading BP memory\n");
return;
}
if (VdmBreakPoint.Flags & VDMBP_SET) {
if ((VdmBreakPoint.Seg == selector) &&
(VdmBreakPoint.Offset == offset) &&
!(VdmBreakPoint.Flags ^ flags))
{
VdmBreakPoint.Count = count;
VdmBreakPoint.Flags |= VDMBP_FLUSH;
if (!(VdmBreakPoint.Flags & VDMBP_ENABLED)) {
EnableBreakPoint(&VdmBreakPoint);
}
WRITEMEM((PVOID)lpTmp, &VdmBreakPoint, sizeof(VDM_BREAKPOINT));
PRINTF("breakpoint %d redefined\n", BPNum);
return;
}
}
}
for (lpTmp = lpAddress, BPNum = 0; BPNum < MAX_VDM_BREAKPOINTS;
BPNum++,lpTmp+=sizeof(VDM_BREAKPOINT)) {
if (!READMEM((PVOID)lpTmp, &VdmBreakPoint, sizeof(VDM_BREAKPOINT))) {
PRINTF("Error reading BP memory\n");
return;
}
if (!(VdmBreakPoint.Flags & VDMBP_SET)) {
VdmBreakPoint.Seg = selector;
VdmBreakPoint.Offset = offset;
VdmBreakPoint.Count = count;
VdmBreakPoint.Flags = VDMBP_SET | VDMBP_FLUSH;
EnableBreakPoint(&VdmBreakPoint);
WRITEMEM((PVOID)lpTmp, &VdmBreakPoint, sizeof(VDM_BREAKPOINT));
return;
}
}
}
