process_file_name.hpp

Go to the documentation of this file.

//===- include/pstore/os/process_file_name.hpp ------------*- mode: C++ -*-===//
//*                                       __ _ _                                    *
//*  _ __  _ __ ___   ___ ___  ___ ___   / _(_) | ___   _ __   __ _ _ __ ___   ___  *
//* | '_ \| '__/ _ \ / __/ _ \/ __/ __| | |_| | |/ _ \ | '_ \ / _` | '_ ` _ \ / _ \ *
//* | |_) | | | (_) | (_|  __/\__ \__ \ |  _| | |  __/ | | | | (_| | | | | | |  __/ *
//* | .__/|_|  \___/ \___\___||___/___/ |_| |_|_|\___| |_| |_|\__,_|_| |_| |_|\___| *
//* |_|                                                                             *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_OS_PROCESS_FILE_NAME_HPP
#define PSTORE_OS_PROCESS_FILE_NAME_HPP

#include <cerrno>

#include "pstore/support/error.hpp"

namespace pstore {

    std::string process_file_name ();

} // end namespace pstore


namespace pstore {

    template <typename ProcessPathFunction, typename BufferType>
    std::size_t process_file_name (ProcessPathFunction get_process_path, BufferType & buffer) {
        static_assert (std::is_same<typename BufferType::value_type, char>::value,
                       "BufferType::value_type must be char");
        constexpr auto const max_reasonable_size = std::size_t{16 * 1024 * 1024};
        auto size = std::size_t{0};
        auto next_size = std::max (buffer.capacity (), std::size_t{2});
        do {
            buffer.resize (next_size);
            size = get_process_path (::pstore::gsl::make_span (buffer));
            next_size = std::max (size, next_size + next_size / 2U);
        } while ((size == 0 || size >= buffer.size ()) && next_size < max_reasonable_size);
        if (next_size >= max_reasonable_size) {
            raise (error_code::unknown_process_path);
        }
        return size;
    }

    namespace freebsd {
        template <typename SpanType, typename SysCtlFunction, typename BufferType>
        std::size_t process_file_name (SpanType mib, SysCtlFunction ctl, BufferType & buffer) {
            static_assert (std::is_same<typename SpanType::element_type, int>::value,
                           "mib must be a span of integers");

            auto read_link = [&mib, &ctl] (gsl::span<char> const b) {
                PSTORE_ASSERT (b.size () >= 0);
                auto const buffer_size = static_cast<std::size_t> (b.size ());
                auto length = buffer_size;
                errno = 0;
                if (ctl (mib.data (), static_cast<unsigned int> (mib.size ()), b.data (), &length,
                         nullptr, 0) == -1) {
                    if (errno == ENOMEM) {
                        return buffer_size;
                    }
                    raise (errno_erc{errno}, "sysctl(CTL_KERN/KERN_PROC/KERN_PROC_PATHNAME)");
                }
                // Subtract 1 to ignore the terminating null character.
                return std::max (std::size_t{1}, length) - std::size_t{1};
            };
            return pstore::process_file_name (read_link, buffer);
        }
    } // end namespace freebsd
} // end namespace pstore
#endif // PSTORE_OS_PROCESS_FILE_NAME_HPP