Speicherzugriffsfehler (Speicherabzug geschrieben)

[Ramanujan]

Mein C++-Programm stürzt nach recht langer Zeit irgendwann mit der Meldung

Speicherzugriffsfehler (Speicherabzug geschrieben)

ab.
Erste Frage wäre jetzt, wohin dieser Speicherabzug denn geschrieben wurde? Aber vermutlich kann man damit eh nichts anfangen

Da das Programm mit höchster Optimierung meist erst so nach 10 Stunden abstürzt, kommt ein Debugger eher nicht in Frage.

Ich hatte jetzt versucht, den Fehler abzufangen (dafür schreibe ich in eine globale Variable Werte, die mir sagen sollen, wo mein Programm ungefähr zum Absturzzeitpunkt war):

struct sigaction sa;
    memset(&sa, 0, sizeof(struct sigaction));
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = segfault_sigaction; // Funktion, in der der Inhalt der globalen Variablen ausgegeben wird
    sa.sa_flags   = SA_SIGINFO;
    sigaction(SIGSEGV, &sa, NULL);

Wenn ich einen SegFault provoziere, funktioniert das auch. Aber scheinbar wird von dem Fehler in meinem Programm kein SIGSEGV geworfen, aber trotzdem "Speicherzugriffsfehler" angezeigt. Kann mir jemand sagen, wie ich den Fehler noch auffangen könnte? Könnte es irgendein anderes Signal sein?

[SeppJ]

Doch, Core Dumps sind sogar äußerst nützlich bei Fehlern dieser Art. Falls das ein Ubuntu oder verwandtes System ist, kann es sein, dass du diese Meldung bekommst, obwohl dein System ein Dumplimit von 0 (weil das auf vielen Systemen aus gutem Grund der Standard ist). Du kannst mit ulimit oder ähnlichen Tools das Limit hoch setzen (hier am besten auf unlimited). Dann findest du eine core-Datei im Arbeitsverzeichnis des abgestürzten Programms (Name und Pfad der Datei sind ebenfalls anpassbar, aber das ist der Standard). Eventuell landet die Datei auch in /var/cache/abrt oder ähnlichen Verzeichnissen. Guck mal nach, vielleicht ist sie schon da. Wie genau mit Core Dumps umgegangen wird steht in /proc/sys/kernel/core_pattern:

Linuxkerneldokumentation schrieb:

core_pattern:

core_pattern is used to specify a core dumpfile pattern name.
. max length 128 characters; default value is "core"
. core_pattern is used as a pattern template for the output filename;
  certain string patterns (beginning with '%') are substituted with
  their actual values.
. backward compatibility with core_uses_pid:
	If core_pattern does not include "%p" (default does not)
	and core_uses_pid is set, then .PID will be appended to
	the filename.
. corename format specifiers:
	%<NUL>	'%' is dropped
	%%	output one '%'
	%p	pid
	%P	global pid (init PID namespace)
	%i	tid
	%I	global tid (init PID namespace)
	%u	uid
	%g	gid
	%d	dump mode, matches PR_SET_DUMPABLE and
		/proc/sys/fs/suid_dumpable
	%s	signal number
	%t	UNIX time of dump
	%h	hostname
	%e	executable filename (may be shortened)
	%E	executable path
	%<OTHER> both are dropped
. If the first character of the pattern is a '|', the kernel will treat
  the rest of the pattern as a command to run.  The core dump will be
  written to the standard input of that program instead of to a file.

Wenn du den Core Dump dann hast: Du kannst das Programm und das Image im Debugger laden und siehst dann, was vorgefallen ist. Dein Programm sollte dazu natürlich mit Debugsymbolen übersetzt werden, sonst kannst du vermutlich herzlich wenig damit anfangen. Optimal wäre auch das Ausschalten von Optimierungen, falls das dann nicht zu langsam wird.

Andere Methoden der Fehlerfindung/-vermeidung (deine eigene ist eher ungeeignet):

• Compilerwarnungen auf Maximum setzen und Warnungen wie Fehler behandeln.
• Immer die richtigen Datentypen benutzen (z.B. kein unsigned int, wo ein size_t richtig wäre).
• Modernes C++ programmieren. Kein C mit cout.
• Kleinen Testfall erstellen. Damit:
• Programm mit valgrind überprüfen
• Programm mit STL-Bereichsprüfungen übersetzen und laufen lassen (Du benutzt doch STL-Container, oder? Siehe Punkt über modernes C++. Es dürfen natürlich auch nicht-STL-Container sein, aber Hauptsache eine Containerklasse, so dass man leicht Bereichsprüfungen einbauen/aktivieren kann)
• Hier im Forum fragen

[Ramanujan]

ulimit zeigt "unlimited" als Ausgabe an, das scheint also schon mal ok zu sein. Im Arbeitsverzeichnis ist nichts, der Ordner /var/cache/abrt existiert nicht. Wo könnte die Datei noch gelandet sein?

Übersetzt hab ich das Programm mit -g1, damit sollte mir beim Debugger ganz grob was angezeigt werden (wenn ich denn dann die Datei hätte).

Ein kleinen Testfall (mit n = 10^5 Punkten) verläuft fehlerfrei. Auch n = 10^8 funktioniert, bei n=3*10^8 stürzt das Programm dann manchmal ab. Ich glaube nicht, dass es sich um einen einfachen Fehler handelt. Vermutlich hab ich in den 2000 Zeilen Code irgendwo einen Sonderfall vergessen, der ganz selten auftritt.

Ich hab mein Programm jetzt einfach mal mit valgrind gestartet. Vielleicht hab ich in ein paar Tagen ein Ergebnis

[SeppJ]

Ramanujan schrieb:

ulimit zeigt "unlimited" als Ausgabe an, das scheint also schon mal ok zu sein. Im Arbeitsverzeichnis ist nichts, der Ordner /var/cache/abrt existiert nicht. Wo könnte die Datei noch gelandet sein?

Was steht in /proc/sys/kernel?

Übersetzt hab ich das Programm mit -g1, damit sollte mir beim Debugger ganz grob was angezeigt werden (wenn ich denn dann die Datei hätte).

Ein kleinen Testfall (mit n = 10^5 Punkten) verläuft fehlerfrei. [/quote]Auch mit valgrind und/oder STL-Debugchecks (beim GCC mittels -D_GLIBCXX_DEBUG beim Übersetzen aktivieren)? Die können eventuell schon bei kleinen Läufen einen Fehler entdecken, der dann erst nach langer Zeit zum Absturz führt.

Auch n = 10^8 funktioniert, bei n=3*10^8 stürzt das Programm dann manchmal ab. Ich glaube nicht, dass es sich um einen einfachen Fehler handelt. Vermutlich hab ich in den 2000 Zeilen Code irgendwo einen Sonderfall vergessen, der ganz selten auftritt.

Ja, vermutlich dies. Ins Blaue geraten würde ich auf irgendeine Art von Überlauf tippen, weil an einer Stelle ein unpassend kleiner Datentyp benutzt wurde.

Ich hab mein Programm jetzt einfach mal mit valgrind gestartet. Vielleicht hab ich in ein paar Tagen ein Ergebnis

Es kann durchaus auch ein recht minimaler Lauf sein, du musst nicht tagelang warten, bis ein extrem lahmer valgrind-Run abstürzt.

Noch ein paar Ideen/Hinweise:
Kann dein Programm seinen internen Zustand speichern, so dass du erst mit einer optimierten Executable bis nahe an den Fehlerpunkt ausführst, dann die Daten rausschreibst, dann mit einer Debugexecutable die Daten lädst und weiter machst? So brauchst du nicht immer 10 Stunden warten.

[Ramanujan]

In /proc/sys/kernel stehen viele Dateien. ls liefert:

acct                ftrace_dump_on_oops     modprobe                           numa_balancing_settle_count  print-fatal-signals           sched_min_granularity_ns     shm_next_id
acpi_video_flags    ftrace_enabled          modules_disabled                   osrelease                    printk                        sched_nr_migrate             shm_rmid_forced
auto_msgmni         hostname                msgmax                             ostype                       printk_delay                  sched_rr_timeslice_ms        softlockup_panic
blk_iopoll          hotplug                 msgmnb                             overflowgid                  printk_ratelimit              sched_rt_period_us           stack_tracer_enabled
bootloader_type     hung_task_check_count   msgmni                             overflowuid                  printk_ratelimit_burst        sched_rt_runtime_us          sysrq
bootloader_version  hung_task_panic         msg_next_id                        panic                        pty                           sched_shares_window_ns       tainted
cad_pid             hung_task_timeout_secs  ngroups_max                        panic_on_io_nmi              random                        sched_time_avg_ms            threads-max
cap_last_cap        hung_task_warnings      nmi_watchdog                       panic_on_oops                randomize_va_space            sched_tunable_scaling        timer_migration
compat-log          io_delay_type           ns_last_pid                        panic_on_unrecovered_nmi     real-root-dev                 sched_wakeup_granularity_ns  traceoff_on_warning
core_pattern        kexec_load_disabled     numa_balancing                     perf_cpu_time_max_percent    sched_autogroup_enabled       sem                          unknown_nmi_panic
core_pipe_limit     keys                    numa_balancing_migrate_deferred    perf_event_max_sample_rate   sched_cfs_bandwidth_slice_us  sem_next_id                  usermodehelper
core_uses_pid       kptr_restrict           numa_balancing_scan_delay_ms       perf_event_mlock_kb          sched_child_runs_first        sg-big-buff                  version
ctrl-alt-del        kstack_depth_to_print   numa_balancing_scan_period_max_ms  perf_event_paranoid          sched_domain                  shmall                       watchdog
dmesg_restrict      latencytop              numa_balancing_scan_period_min_ms  pid_max                      sched_latency_ns              shmmax                       watchdog_thresh
domainname          max_lock_depth          numa_balancing_scan_size_mb        poweroff_cmd                 sched_migration_cost_ns       shmmni                       yama

Könnte davon eine relevant sein?

Ich hab meinen kleinen Testfall mit valgrind ausgeführt: Dieser lief aber problemlos durch. Mit -D_GLIBCXX_DEBUG hatte ich gerade beim Kompilieren einen Linkerfehler (boost::program_options), da muss ich nochmal gucken.

Das Speichern des internen Zustand geht nicht und eine Implementierung recht aufwändig.

[SeppJ]

In core_pattern steht drin, was mit Core Dumps passiert. Siehe meine erste Antwort.

[Ramanujan]

In core_pattern steht:

|/usr/share/apport/apport %p %s %c %P

Die Datei /usr/share/apport/apport scheint ein phyton-Skript zu sein:

#!/usr/bin/python3

# Collect information about a crash and create a report in the directory
# specified by apport.fileutils.report_dir.
# See https://wiki.ubuntu.com/Apport for details.
#
# Copyright (c) 2006 - 2011 Canonical Ltd.
# Author: Martin Pitt <martin.pitt@ubuntu.com>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
# the full text of the license.

import sys, os, os.path, subprocess, time, traceback, pwd, io
import signal, inspect, grp, fcntl

import apport, apport.fileutils

#################################################################
#
# functions
#
#################################################################

def check_lock():
    '''Abort if another instance of apport is already running.

    This avoids bringing down the system to its knees if there is a series of
    crashes.'''

    # create a lock file
    lockfile = os.path.join(apport.fileutils.report_dir, '.lock')
    try:
        fd = os.open(lockfile, os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW)
    except OSError as e:
        error_log('cannot create lock file (uid %i): %s' % (os.getuid(), str(e)))
        sys.exit(1)

    try:
        fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
    except IOError:
        error_log('another apport instance is already running, aborting')
        sys.exit(1)

def drop_privileges(pid, partial=False):
    '''Change user and group to match the given target process.'''

    stat = None
    try:
        stat = os.stat('/proc/%s/stat' % pid)
    except OSError as e:
        raise ValueError('Invalid process ID: ' + str(e))

    if partial:
        effective_gid = os.getegid()
        effective_uid = os.geteuid()
    else:
        effective_gid = stat.st_gid
        effective_uid = stat.st_uid

    os.setregid(stat.st_gid, effective_gid)
    os.setreuid(stat.st_uid, effective_uid)
    assert os.getegid() == effective_gid
    assert os.getgid() == stat.st_gid
    assert os.geteuid() == effective_uid
    assert os.getuid() == stat.st_uid

def init_error_log():
    '''Open a suitable error log if sys.stderr is not a tty.'''

    if not os.isatty(2):
        log = os.environ.get('APPORT_LOG_FILE', '/var/log/apport.log')
        try:
            f = os.open(log, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
            try:
                admgid = grp.getgrnam('adm')[2]
                os.chown(log, -1, admgid)
                os.chmod(log, 0o640)
            except KeyError:
                pass  # if group adm doesn't exist, just leave it as root
        except OSError:  # on a permission error, don't touch stderr
            return
        os.dup2(f, 1)
        os.dup2(f, 2)
        sys.stderr = os.fdopen(2, 'wb')
        if sys.version_info.major >= 3:
            sys.stderr = io.TextIOWrapper(sys.stderr)
        sys.stdout = sys.stderr

def error_log(msg):
    '''Output something to the error log.'''

    apport.error('apport (pid %s) %s: %s', os.getpid(), time.asctime(), msg)

def _log_signal_handler(sgn, frame):
    '''Internal apport signal handler. Just log the signal handler and exit.'''

    # reset handler so that we do not get stuck in loops
    signal.signal(sgn, signal.SIG_IGN)
    try:
        error_log('Got signal %i, aborting; frame:' % sgn)
        for s in inspect.stack():
            error_log(str(s))
    except:
        pass
    sys.exit(1)

def setup_signals():
    '''Install a signal handler for all crash-like signals, so that apport is
    not called on itself when apport crashed.'''

    signal.signal(signal.SIGILL, _log_signal_handler)
    signal.signal(signal.SIGABRT, _log_signal_handler)
    signal.signal(signal.SIGFPE, _log_signal_handler)
    signal.signal(signal.SIGSEGV, _log_signal_handler)
    signal.signal(signal.SIGPIPE, _log_signal_handler)
    signal.signal(signal.SIGBUS, _log_signal_handler)

def write_user_coredump(pid, cwd, limit, from_report=None):
    '''Write the core into the current directory if ulimit requests it.'''

    # three cases:
    # limit == 0: do not write anything
    # limit < 0: unlimited, write out everything
    # limit nonzero: crashed process' core size ulimit in bytes

    if limit == 0:
        return

    core_path = os.path.join(cwd, 'core')
    try:
        with open('/proc/sys/kernel/core_uses_pid') as f:
            if f.read().strip() != '0':
                core_path += '.' + str(pid)
        core_file = os.open(core_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
    except (OSError, IOError):
        return

    error_log('writing core dump to %s (limit: %s)' % (core_path, str(limit)))

    written = 0

    # Priming read
    if from_report:
        r = apport.Report()
        with open(from_report, 'rb') as f:
            r.load(f)
        core_size = len(r['CoreDump'])
        if limit > 0 and core_size > limit:
            error_log('aborting core dump writing, size %i exceeds current limit' % core_size)
            os.close(core_file)
            os.unlink(core_path)
            return
        error_log('writing core dump %s of size %i' % (core_path, core_size))
        os.write(core_file, r['CoreDump'])
    else:
        # read from stdin
        block = os.read(0, 1048576)

        while True:
            size = len(block)
            if size == 0:
                break
            written += size
            if limit > 0 and written > limit:
                error_log('aborting core dump writing, size exceeds current limit %i' % limit)
                os.close(core_file)
                os.unlink(core_path)
                return
            if os.write(core_file, block) != size:
                error_log('aborting core dump writing, could not write')
                os.close(core_file)
                os.unlink(core_path)
                return
            block = os.read(0, 1048576)

    os.close(core_file)
    return core_path

def usable_ram():
    '''Return how many bytes of RAM is currently available that can be
    allocated without causing major thrashing.'''

    # abuse our excellent RFC822 parser to parse /proc/meminfo
    r = apport.Report()
    with open('/proc/meminfo', 'rb') as f:
        r.load(f)

    memfree = int(r['MemFree'].split()[0])
    cached = int(r['Cached'].split()[0])
    writeback = int(r['Writeback'].split()[0])

    return (memfree + cached - writeback) * 1024

def is_closing_session(pid, uid):
    '''Check if pid is in a closing user session.

    During that, crashes are common as the session D-BUS and X.org are going
    away, etc. These crash reports are mostly noise, so should be ignored.
    '''
    with open('/proc/%s/environ' % pid) as e:
        env = e.read().split('\0')
    for e in env:
        if e.startswith('DBUS_SESSION_BUS_ADDRESS='):
            dbus_addr = e.split('=', 1)[1]
            break
    else:
        error_log('is_closing_session(): no DBUS_SESSION_BUS_ADDRESS in environment')
        return False

    orig_uid = os.geteuid()
    os.setresuid(uid, uid, -1)
    try:
        gdbus = subprocess.Popen(['/usr/bin/gdbus', 'call', '-e', '-d',
                                  'org.gnome.SessionManager', '-o', '/org/gnome/SessionManager', '-m',
                                  'org.gnome.SessionManager.IsSessionRunning'], stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE, env={'DBUS_SESSION_BUS_ADDRESS': dbus_addr})
        (out, err) = gdbus.communicate()
        if err:
            error_log('gdbus call error: ' + err.decode('UTF-8'))
    except OSError as e:
        error_log('gdbus call failed, cannot determine running session: ' + str(e))
        return False
    finally:
        os.setresuid(orig_uid, orig_uid, -1)
    error_log('debug: session gdbus call: ' + out.decode('UTF-8'))
    if out.startswith(b'(false,'):
        return True

    return False

#################################################################
#
# main
#
#################################################################

if len(sys.argv) not in (4, 5):
    try:
        print('Usage: %s <pid> <signal number> <core file ulimit> [global pid]' % sys.argv[0])
        print('The core dump is read from stdin.')
    except IOError:
        # sys.stderr might not actually exist, expecially not when being called
        # from the kernel
        pass
    sys.exit(1)

init_error_log()

# Check if we received a valid global PID (kernel >= 3.12). If we do,
# then compare it with the local PID. If they don't match, it's an
# indication that the crash originated from another PID namespace. In that
# case, attempt to forward the crash to apport in that namespace. If
# apport can't be found, then simply log an entry in the host error log
# and exit 0.
if len(sys.argv) == 5 and sys.argv[4].isdigit() and sys.argv[4] != sys.argv[1]:
    if os.path.exists('/proc/%s/root/%s' % (sys.argv[4], __file__)):
        error_log('pid %s (host pid %s) crashed in a container with apport '
                  'support, forwarding' % (sys.argv[1], sys.argv[4]))
        sys.stderr.flush()
        os.execv('/usr/sbin/chroot', ('chroot', '/proc/%s/root/' % sys.argv[4],
                                      __file__, sys.argv[1], sys.argv[2],
                                      sys.argv[3]))
    else:
        error_log('pid %s crashed in a container without apport support' % sys.argv[4])
        sys.exit(0)

check_lock()

try:
    setup_signals()

    (pid, signum, core_ulimit) = sys.argv[1:4]

    # drop our process priority level to not disturb userspace so much
    try:
        os.nice(10)
    except OSError:
        pass  # *shrug*, we tried

    # Partially drop privs to gain proper os.access() checks
    drop_privileges(pid, True)

    # try to find the core dump file; if path is relative, prepend cwd of
    # crashed process
    cwd = os.readlink('/proc/' + pid + '/cwd')

    error_log('called for pid %s, signal %s, core limit %s' % (pid, signum, core_ulimit))

    try:
        core_ulimit = int(core_ulimit)
    except ValueError:
        error_log('core limit is invalid, disabling core files')
        core_ulimit = 0
    # clamp core_ulimit to a sensible size, for -1 the kernel reports something
    # absurdly big
    if core_ulimit > 9223372036854775807:
        error_log('ignoring implausibly big core limit, treating as unlimited')
        core_ulimit = -1
    # ulimit specifies blocks, which are kB
    if core_ulimit > 0:
        core_ulimit *= 1024

    # ignore SIGQUIT (it's usually deliberately generated by users)
    if signum == str(signal.SIGQUIT):
        drop_privileges(pid)
        write_user_coredump(pid, cwd, core_ulimit)
        sys.exit(0)

    try:
        pidstat = os.stat('/proc/%s/stat' % pid)
    except OSError:
        error_log('Invalid PID')
        sys.exit(1)

    # check if the executable was modified after the process started (e. g.
    # package got upgraded in between)
    exe_mtime = os.stat('/proc/%s/exe' % pid).st_mtime
    process_start = os.lstat('/proc/%s/cmdline' % pid).st_mtime
    if not os.path.exists(os.readlink('/proc/%s/exe' % pid)) or exe_mtime > process_start:
        error_log('executable was modified after program start, ignoring')
        sys.exit(1)

    info = apport.Report('Crash')
    info['Signal'] = signum
    if sys.version_info.major < 3:
        info['CoreDump'] = (sys.stdin, True, usable_ram() * 3 / 4, True)
    else:
        # read binary data from stdio
        info['CoreDump'] = (sys.stdin.detach(), True, usable_ram() * 3 / 4, True)

    # We already need this here to figure out the ExecutableName (for scripts,
    # etc).
    info.add_proc_info(pid)

    if 'ExecutablePath' not in info:
        error_log('could not determine ExecutablePath, aborting')
        sys.exit(1)

    subject = info['ExecutablePath'].replace('/', '_')
    base = '%s.%s.%s.hanging' % (subject, str(pidstat.st_uid), pid)
    hanging = os.path.join(apport.fileutils.report_dir, base)

    if os.path.exists(hanging):
        if (os.stat('/proc/uptime').st_ctime < os.stat(hanging).st_mtime):
            info['ProblemType'] = 'Hang'
        os.unlink(hanging)

    if 'InterpreterPath' in info:
        error_log('script: %s, interpreted by %s (command line "%s")' %
                  (info['ExecutablePath'], info['InterpreterPath'],
                   info['ProcCmdline']))
    else:
        error_log('executable: %s (command line "%s")' %
                  (info['ExecutablePath'], info['ProcCmdline']))

    # ignore non-package binaries (unless configured otherwise)
    if not apport.fileutils.likely_packaged(info['ExecutablePath']):
        if not apport.fileutils.get_config('main', 'unpackaged', False, bool=True):
            error_log('executable does not belong to a package, ignoring')
            # check if the user wants a core dump
            drop_privileges(pid)
            write_user_coredump(pid, cwd, core_ulimit)
            sys.exit(1)

    # ignore SIGXCPU and SIGXFSZ since this indicates some external
    # influence changing soft RLIMIT values when running programs.
    if signum in [str(signal.SIGXCPU), str(signal.SIGXFSZ)]:
        error_log('Ignoring signal %s (caused by exceeding soft RLIMIT)' % signum)
        drop_privileges(pid)
        write_user_coredump(pid, cwd, core_ulimit)
        sys.exit(0)

    # ignore blacklisted binaries
    if info.check_ignored():
        error_log('executable version is blacklisted, ignoring')
        sys.exit(1)

    if is_closing_session(pid, pidstat.st_uid):
        error_log('happens for shutting down session, ignoring')
        sys.exit(1)

    crash_counter = 0

    # Create crash report file descriptor for writing the report into
    # report_dir
    try:
        report = '%s/%s.%i.crash' % (apport.fileutils.report_dir, info['ExecutablePath'].replace('/', '_'), pidstat.st_uid)
        if os.path.exists(report):
            if apport.fileutils.seen_report(report):
                # do not flood the logs and the user with repeated crashes
                with open(report, 'rb') as f:
                    crash_counter = apport.fileutils.get_recent_crashes(f)
                crash_counter += 1
                if crash_counter > 1:
                    drop_privileges(pid)
                    write_user_coredump(pid, cwd, core_ulimit)
                    error_log('this executable already crashed %i times, ignoring' % crash_counter)
                    sys.exit(1)
                # remove the old file, so that we can create the new one with
                # os.O_CREAT|os.O_EXCL
                os.unlink(report)
            else:
                error_log('apport: report %s already exists and unseen, doing nothing to avoid disk usage DoS' % report)
                drop_privileges(pid)
                write_user_coredump(pid, cwd, core_ulimit)
                sys.exit(1)
        reportfile = os.fdopen(os.open(report, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0), 'wb')
        assert reportfile.fileno() > sys.stderr.fileno()

        # Make sure the crash reporting daemon can read this report
        try:
            gid = pwd.getpwnam('whoopsie').pw_gid
            os.chown(report, pidstat.st_uid, gid)
        except (OSError, KeyError):
            os.chown(report, pidstat.st_uid, pidstat.st_gid)
    except (OSError, IOError) as e:
        error_log('Could not create report file: %s' % str(e))
        sys.exit(1)

    # Totally drop privs before writing out the reportfile.
    drop_privileges(pid)

    info.add_user_info()
    info.add_os_info()

    if crash_counter > 0:
        info['CrashCounter'] = '%i' % crash_counter

    try:
        info.write(reportfile)
        if reportfile != sys.stderr:
            # Ensure that the file gets written to disk in the event of an
            # Upstart crash.
            if info.get('ExecutablePath', '') == '/sbin/init':
                reportfile.flush()
                os.fsync(reportfile.fileno())
                parent_directory = os.path.dirname(report)
                try:
                    fd = os.open(parent_directory, os.O_RDONLY)
                    os.fsync(fd)
                finally:
                    os.close(fd)
            reportfile.close()
    except IOError:
        if reportfile != sys.stderr:
            os.unlink(report)
        raise
    if report:
        os.chmod(report, 0o640)
    if reportfile != sys.stderr:
        error_log('wrote report %s' % report)

    # Check if the user wants a core file. We need to create that from the
    # written report, as we can only read stdin once and write_user_coredump()
    # might abort reading from stdin and remove the written core file when
    # core_ulimit is > 0 and smaller than the core size.
    write_user_coredump(pid, cwd, core_ulimit, from_report=report)

except (SystemExit, KeyboardInterrupt):
    raise
except Exception as e:
    error_log('Unhandled exception:')
    traceback.print_exc()
    error_log('pid: %i, uid: %i, gid: %i, euid: %i, egid: %i' % (
              os.getpid(), os.getuid(), os.getgid(), os.geteuid(), os.getegid()))
    error_log('environment: %s' % str(os.environ))

Ich werd daraus aber immer noch nicht schlau, wo der Core Dump gelandet ist.

[SeppJ]

Apport ist der Ubuntu Crash-Reporter. Wie in meiner ersten Antwort bereits geschrieben, sollte der eigentlich eine Kopie des Core Dumps in /var/crash (oder ähnlich) oder im Arbeitsverzeichnis des Programms anlegen. Wobei mir gerade etwas auffällt:

Ramanujan schrieb:

ulimit zeigt "unlimited" als Ausgabe an, das scheint also schon mal ok zu sein.

Kann's sein, dass du einfach nur ulimit ohne Parameter aufgerufen hast? ulimit ist für alle möglichen Grenzwerte zuständig, der Default-Grenzwert ist die maximale Dateigröße. Ich hatte erwartet, dass du halbwegs weißt, was was macht oder unbekannte Kommandos wenigstens kurz nachschlägst.

[Ramanujan]

Ja, ich hab es ohne Parameter aufgerufen. Unwissenheit.
Parameter -c ist der Richtige oder? Der stand auf 0, ich hab ihn jetzt auf unlimited gesetzt. Mal sehen, ob ich morgen einen Dump vorfinde.

Edit:
Hm, ich finde immer noch keinen Crash-Dump. "ulimit -c" steht definitiv auf unlimited. Im Arbeitsverzeichnis ist nichts und auch nicht in /var/crash (abgesehen von einer alten .crash-Datei, ich geh deshalb davon aus, dass Dumps dort landen müssten).

Über ein paar Debug-Ausgaben (jeweils mit flush) konnte ich Stelle aber recht weit eingrenzen. Vielleicht finde ich den Bug jetzt.