|Message||The system call level is not correct.|
This appears to be a raw Win32 error. More information may be available in error 0x8007007C.
This is a Blue Screen of Death stop code. More information is available in the Knowledge Base article Bug Check 0x7C: BUGCODE_NDIS_DRIVER.
This code indicates success, rather than an error. This may not be the correct interpretation of this code, or possibly the program is handling errors incorrectly.
|Description||The default facility code.|
|Error Code||124 (0x007c)|
From the official documentation:
When a bus driver detects that child devices have been plugged in or unplugged, it informs the Plug and Play (PnP) manager. In response, the PnP manager asks the bus driver to create a physical device object (PDO) for each child device that is connected to the parent device (that is, the bus).
Source: WDM Concepts for WDF Drivers
To get the required information, open a command prompt and run the following command:
wmic path Win32_PnPSignedDriver where "pdo like '%0000007c'" get devicename,pdo
Was having same troubles some time ago with my project of converting CRIU images into core dumps. It is fully written in python(even elf structures are in ctypes), so it could be used as a guide. See https://github.com/efiop/criu-coredump .I.e. how everything is structured could be seen here https://github.com/efiop/criu-coredump/blob/master/criu_coredump/core_dump.py .
Have you tried installing the assembly with the UNSAFE permission set option?
I have System.ServiceModel.Internals (v4 from GAC) installed on SQL Server 11.0.5058 as UNSAFE, I don't know if you will be having versioning issues as well but I believe the assembly can only be installed as unsafe as it may access unmanaged resources.
From your error message:
[found unmanaged pointer] [expected unmanaged pointer] Unexpected type on the stack.
I understand this as Expected Unmanaged pointer, found unmanaged pointer, unmanaged pointer not allowed.
See https://msdn.microsoft.com/en-us/library/ms189566.aspx for definitions of permission sets.
On most microcontrollers, there isn't any code beyond what you put there. In most cases, if an exception occurs and you haven't defined a handler for it, the processor would have no idea how to put up a "Sorry, a system error occurred" dialog box. Using two bytes for a "branch-to-self" instruction is enough to yield a predictable response to an exception; without particular knowledge of any better course of action, a branch-to-self or forced reset is probably as good a response as anything.
PS--Some compilers for various platforms will omit vectors for unused interrupts or exceptions; if such exceptions occur unexpectedly, weird and bizarre things can happen. Some compilers will produce code that will force an immediate reset (note that if watchdog timer is enabled, a jump-to-self will cause a reset, eventually). Some compilers generate an immediate return-from-interrupt (which on some CPU's may be useless, and on others can cause bad behavior). My favorite pattern would be to have all unused interrupts make a call (not a branch) to an UnexpectedInterrupt label, which in the absence of any explicit definition will point to a branch-to-self instruction. If one does that, an UnexpectedInterrupt handler can pop the stack and record what type of unexpected interrupt occurred. I've not seen such a pattern, though, outside my own manually-generated interrupt vector tables.
This is not an answer to the question but a suggestion to do it differently.
Instead of using a
List<byte> and manually doing all the conversions (while certainly possible, it's cumbersome), use a stream and a
BinaryWriter - the stream can be a memory stream if you want to buffer the image in memory or a file stream if you want to write it to disk right away.
BinaryWriter against the stream makes the conversions a lot simpler (and you can still manually convert parts of the data easily, if you need to do so).
Here's a short example:
var ms = new MemoryStream(); var bw = new BinaryWriter(ms, Encoding.ASCII); bw.Write("DDS "); bw.Write(124); // writes 4 bytes bw.Write((byte) 124); // writes 1 byte ...
Use whichever overload of
Write() you need to output the right bytes. (This short example omits cleaning up things but if you use a file stream, you'll need to make sure that you properly close it.)
Just as a heads-up for further PIC32 exception debugging, the exception codes and all the bits in the 'CAUSE' register (the value you're reading into your _excep_code variable before and-ing all the other bits away) are defined in:
PIC32 Family Reference Manual, Section 2.12.9 CAUSE Register http://ww1.microchip.com/downloads/en/DeviceDoc/61113C.pdf
[found ref 'System.String'] Expected numeric type on the stack
The stack trace tells the tale, the CLR verifier checked the stack and found an unexpected type, a string instead of a number. That's pretty bad. The relevant method that's executing, the stack trace is not complete so we can't trace it all the way back, is System.Runtime.Diagnostics.DiagnosticsEventProvider.WriteTransferEvent().
This is a .NET 4 addition in the .NET Framework, it supports ETW (Event Tracing for Windows). A disassembler can show what code uses it, through several layers, that for example the System.ServiceModel.Channels.HttpRequestContext.TraceHttpMessageReceived() calls it.
In other words, we are firmly in WCF land, it received a message over HTTP and it generates an ETW event so it can be traced by ETW tooling. The call originated in System.ServiceModel.dll, the core WCF assembly, the ETW tracing code is located in System.ServiceModel.Internals.dll.
So, somehow, and it is getting to be a bit of a foregone conclusion how this could have happened given the nature of the question, the SQL Server machine has two different revisions of these WCF assemblies. They are normally distributed as a pair, part of the basic .NET install. There have been many revisions since .NET 4.0 RTM, versions 4.01, 4.02, 4.03 were slip-streamed through Windows Update for example, these updates in particular affected System.ServiceModel. Not to speak of versions 4.5, 4.5.1, 4.5.2 and 4.6 shipped since then and a few handfuls of KB updates that fixed bugs and patched security problems.
Anticipating the next question: so what's the correct revision of System.ServiceModel.Internals.dll? You can call Microsoft Support and they will tell you: "there isn't one". But you already knew that. So don't do this. If you want to try to make this working anyway then a basic strategy is to first look at the revision number of System.ServiceModel, then try to find a System.ServiceModel.Internals whose revision number is, if not equal, then at least in the ballpark. The one you have now is almost certainly not close, revision 34234 is, roughly, a .NET 4.5.2 revision number.
Is there a reason you have JTAG on in the config bits? If you're using a regular PICKIT3 etc. you probably don't need then JTAG on. Also, I didn't look real hard, but did you turn off the ANALOG pin functions? Both of these are things that will make Digital IO just not work from the get go.
AD1PCFGbits.PCFG = 0xFFFF;
By just dragging the .crash file into Xcode and click "Re-symbolicate", I can get all the iOS methods symbolicated. But not my own app methods.
And I doubt if there is a possibility to get my own app methods symbolicated correctly since iOS6, because for every individual crash, the "start" method has different addresses. They used to be the same and using atos always work.
First, contact InnerActive telling them to fix their software. It's their responsibility.
Meanwhile, if you know how to reproduce the problem, you can try following. Subscribe for all unhandled exceptions (start with Application.UnhandledException, also there're AppDomain.UnhandledException and TaskScheduler.UnobservedTaskException), in the handler search for “Inneractive.Ad.InneractiveAdControl” in the Exception.StackTrace, if found — ignore the exception, and optionally hide or reload the inneractive banner.
sh3-linux-gdb ./myprogram --core=./core
It may be a bug in the old gdb http://sourceware.org/bugzilla/show_bug.cgi?id=9542 - so try newer gdb (7) too.
Also possible that core was dumped in unsupported format. What is target's OS, version?
Can you post the output or
readelf -a core ?
Can someone give me directions on how is structured the Notes section?
The notes section is a concatenation of variable-sized note records. Each note record begins with
ElfW(Nhdr) structure, followed by (variable sized) name (of length
.n_namesz, padded so total size of name on disk is divisible by 4) and data (of length
.n_descsz, similarly padded).
After some tests I figured things out, answering for anyone looking for this information :
Can someone confirm I am going the right way structuring my Elf file this way ?
As GDB is accepting the file, this seems to be the right way of doing. Results shown by readelf -a show the correct structure, good so far.
I am not sure about where should lay the data (note & program sections) into my file : is there a mandatory order, or is this my program headers offset that define where the data is ?
Offsets given to
Phdr.p_offset should point where the data lays in the Elf file. They start at the very beginning of the file.
For example :
The p_offset for the
PT_NOTE program header should be set at
sizeof(ElfW(Ehdr)) + ehdr.e_phnum*sizeof(ElfW(Phdr)).
ehdr.e_phnum being the number of program header present in the Elf file.
PT_LOAD program header, this is a bit longer, cause we will also have to add length of all the note sections. For a "standard" core dump with a note segment containg
NT_AUXV sections, offset for the PT_LOAD data (
Phdr.p_offset) will be :
sizeof(ElfW(Ehdr)) + ehdr.e_phnum*sizeof(ElfW(Phdr)) + sizeof(ElfW(Nhdr)) + sizeof(name_of_section) + sizeof(struct prstatus) + sizeof(ElfW(Nhdr)) + sizeof(name_of_section) + sizeof(struct prpsinfo) + sizeof(ElfW(Nhdr)) + sizeof(name_of_section) + sizeof(struct auxv_t)
If you haven't already tried this, upgrade your mac to OSX 10.8.2. I was running OSX 10.7.5, and upgrading immediately fixed my sybolication woes.
I had tried pretty much everything to get my crash logs to symbolicate. I never had problems before, but a few months had passed since I'd looked at a crash log; at some point during that period I upgraded to Xcode 4.5.2. It seems to me that something with the Xcode 4.5.2 symbolicatecrash perl script does not work correctly on a mac running OSX 10.7.5. In symbolicatecrash, it calls atos to sybolicate an address; it couldn't find the matching symbols, even though I knew for a fact that I had the correct xcarchive. Anyhow, if you can afford the $20, spring for OSX 10.8.2 and hopefully that'll work for you.
Just a little update on this - I still can't get logs to symbolicate in Xcode (and as I've now moved my Xcode projects to a network drive I'm pretty sure I'll never get it to work), however I have found a decent enough solution in PLCrashReporter 1.2. It can locally symbolicate, which while not perfect, is normally specific enough to allow me to hone in on the problem.
It is very simple if you have the archive in your Xcode and a corresponding crash log.
It is possible to debug your application, not with gdb directly but with gdb server. The first thing you have to do is to call gdbserver in the target system (you said in your question that this package is already installed) :
gdbserver AAA.BBB.CCC.DDD:port ./myprogram
It is assume that the target machine is accessible to an IP address :
AAA.BBB.CCC.DDD:port. Once, you have done that, you can call gdb in your development machine by specifying the target remote server :
% gdb ./myprogram % [...] (gdb) target remote AAA.BBB.CCC.DDD:port
Note that the target remote server IP address are the same of the gdbserver.
User contributions licensed under CC BY-SA 3.0