clone.hxx

Go to the documentation of this file.

#pragma once
 
// C
#include <stdint.h>
 
// Linux
#include <linux/sched.h> // sched headers are needed for clone()
#include <sched.h>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/proc/PidFD.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
enum class CloneFlag : uint64_t {
        CHILD_CLEARTID = CLONE_CHILD_CLEARTID,  
        CHILD_SETTID   = CLONE_CHILD_SETTID,    
        CLEAR_SIGHAND  = CLONE_CLEAR_SIGHAND,   
        DETACHED       = CLONE_DETACHED,        
        SHARE_FILES    = CLONE_FILES,           
        SHARE_FS       = CLONE_FS,              
        INTO_CGROUP    = CLONE_INTO_CGROUP,     
        SHARE_IO       = CLONE_IO,              
        NEW_CGROUP     = CLONE_NEWCGROUP,       
        NEW_IPC        = CLONE_NEWIPC,          
        NEW_NET        = CLONE_NEWNET,          
        NEW_MOUNT      = CLONE_NEWNS,           
        NEW_NS         = CLONE_NEWNS,           // just a synonym using the old compatibility name
        NEW_PID        = CLONE_NEWPID,          
        NEW_USER       = CLONE_NEWUSER,         
        NEW_UTS        = CLONE_NEWUTS,          
        SHARE_PARENT   = CLONE_PARENT,          
        PARENT_SETTID  = CLONE_PARENT_SETTID,   
        PIDFD          = CLONE_PIDFD,           
        PTRACE         = CLONE_PTRACE,          
        SETTLS         = CLONE_SETTLS,          
        SIGHAND        = CLONE_SIGHAND,         
        SHARE_SYSVSEM  = CLONE_SYSVSEM,         
        THREAD         = CLONE_THREAD,          
        UNTRACED       = CLONE_UNTRACED,        
        VFORK          = CLONE_VFORK,           
        SHARE_VM       = CLONE_VM               
};
 
using CloneFlags = BitMask<CloneFlag>;
 
struct COSMOS_API CloneArgs :
                ::clone_args {
 
        CloneArgs() {
                clear();
        }
 
 
        void clear();
 
        void setFlags(const CloneFlags p_flags) {
                this->flags = p_flags.raw();
        }
 
        void setPidFD(PidFD &fd) {
                this->pidfd = reinterpret_cast<uintptr_t>(&fd.m_fd);
        }
 
        void setChildTID(ThreadID *tid) {
                this->child_tid = reinterpret_cast<uint64_t>(tid);
        }
 
        void setParentTID(ProcessID *pid) {
                this->parent_tid = reinterpret_cast<uint64_t>(pid);
        }
 
 
        void setExitSignal(const Signal sig) {
                this->exit_signal = static_cast<uint64_t>(to_integral(sig.raw()));
        }
 
 
        void setStack(void *p_stack) {
                this->stack = reinterpret_cast<uint64_t>(p_stack);
        }
 
 
        void setTIDs(const ThreadID *tids, size_t num_tids) {
                this->set_tid = reinterpret_cast<uint64_t>(tids);
                this->set_tid_size = num_tids;
        }
 
 
        void setCGroup(const FileDescriptor fd) {
                this->cgroup = static_cast<uint64_t>(fd.raw());
        }
};
 
namespace proc {
 
 
COSMOS_API std::optional<ProcessID> clone(const CloneArgs &args);
 
} // end ns proc
 
} // end ns