source: tests/meta/dumpable.cfa @ 2980ccb8

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// dumpable.cfa -- Check if everything looks correctly set to dump core
//
// Author           : Thierry Delisle
// Created On       : Wed Jan 05 13:53:22 2022
// Last Modified By : Peter A. Buhr
// Last Modified On : Fri Jul 19 07:58:45 2024
// Update Count     : 10
//

#include <errno.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>

#include <fstream.hfa>

extern "C" {
        #include <fcntl.h>
        #include <sys/prctl.h>
        #include <sys/resource.h>
        #include <sys/statvfs.h>
        #include <sys/stat.h>
        #include <sys/types.h>
}

void check_ulimit() {
        struct rlimit rlp;
        getrlimit( RLIMIT_CORE, &rlp );
        if ( rlp.rlim_cur < 536870912 ) {
                serr | "Soft core limit is less than ~500Mb: " | rlp.rlim_cur;
        } // if

        if ( rlp.rlim_max < 536870912 ) {
                serr | "Hard core limit is less than ~500Mb: " | rlp.rlim_max;
        } // if
}

void check_permission() {
        char myExe[PATH_MAX];
        ssize_t n = readlink( "/proc/self/exe", myExe, sizeof(myExe));
        if ( n < 0 ) {
                perror( "readlink(/proc/self/exe ) error" );
                return 1;
        } // if
        myExe[n] = '\0';

        if ( int r = access( myExe, F_OK ); r != 0 ) serr | "Expected current executable does not exist!" | r | errno;
        if ( int r = access( myExe, R_OK ); r != 0 ) serr | "No read access for current executable" | r | errno;

        char myCwd[PATH_MAX];
        if ( getcwd( myCwd, sizeof(myCwd ) ) == 0p ) {
                perror( "getcwd() error" );
                return;
        } // if

        if ( access( myCwd, F_OK ) != 0 ) serr | "Expected current working directory does not exist!";
        if ( access( myCwd, R_OK ) != 0 ) serr | "No read access for current working directory";
        if ( access( myCwd, W_OK ) != 0 ) serr | "No write access for current working directory";
}

void check_free_space() {
        struct statvfs buf;
        if ( statvfs( ".", &buf ) != 0 ) {
                perror( "statvfs() error" );
                return;
        } // if

        uint64_t avail = buf.f_bavail;
        avail *= buf.f_bsize;
        if ( avail < 536870912_l64u ) {
                serr | "Available diskspace is less than ~500Mb: " | avail;
        } // if

        if ( buf.f_favail < 10 ) {
                serr | "Available inodes is less than 10: " | buf.f_favail;
        } // if

        if ( buf.f_flag & ST_RDONLY ) {
                serr | "Filesystem is read only";
        } // if
}

void check_noconflict() {
        const char * name = "./core";
        if ( access( name, F_OK ) == 0 ) serr | "File \"" | name | "\" already exists";
}

void check_dumpflag() {
        int r = prctl( PR_GET_DUMPABLE, 0, 0, 0, 0 );
        if ( r < 0 ) {
                perror( "prctl( PR_GET_DUMPABLE ) error" );
                return;
        } // if

        if ( r != 1 ) serr | "dumpable attribute not set to 1 \"( SUID_DUMP_USER, process is dumpable )\", was" | r;
}

void check_core_pattern() {
        int ret;
        int cp = open( "/proc/sys/kernel/core_pattern", 0, O_RDONLY );

        if ( cp < 0 ) {
                perror( "open(/proc/sys/kernel/core_pattern, O_RDONLY ) error" );
                return;
        } // if

        try {
                const char * expected = "core\n";
                const int sz = sizeof( "core\n" );
                char buf[512];
                ret = read( cp, buf, 512 );
                if ( ret < 0 ) {
                        perror( "core pattern read error" );
                        return;
                } // if

                ret = strncmp( expected, buf, sz - 1 );
                if ( ret != 0 ) {
                        serr | "Apport is supported on your system, which means the test-suite core-dump feature does not work." | nl
                                 | "This is not a test failure, just a limitation on debugging output should a test fail.";
                } // if
        } finally {
                ret = close( cp );
                if ( ret < 0 ) perror( "close( /proc/sys/kernel/core_pattern ) error" );
        } // try
}

int main() {
        check_ulimit();
        check_permission();
        check_free_space();
        check_noconflict();
        check_dumpflag();
        check_core_pattern();
        sout | "Done";
}