thread.hxx

#pragma once
 
// clues
#include <clues/SystemCall.hxx>
#include <clues/items/fs.hxx>
#include <clues/items/futex.hxx>
#include <clues/items/items.hxx>
#include <clues/items/process.hxx>
#include <clues/items/signal.hxx>
#include <clues/items/time.hxx>
#include <clues/sysnrs/generic.hxx>
 
namespace clues {
 
struct CLUES_API SetTIDAddressSystemCall :
                public SystemCall {
 
        SetTIDAddressSystemCall() :
                        SystemCall{SystemCallNr::SET_TID_ADDRESS},
                        address{"addr", "thread ID location"},
                        caller_tid{ItemType::RETVAL, "caller thread ID"} {
                setReturnItem(caller_tid);
                setParameters(address);
        }


        item::GenericPointerValue address;

        item::ThreadIDItem caller_tid;
};
 
struct CLUES_API GetRobustListSystemCall :
                public SystemCall {
 
        GetRobustListSystemCall() :
                        SystemCall{SystemCallNr::GET_ROBUST_LIST},
                        thread_id{ItemType::PARAM_IN, "thread ID"},
                        list_head{"head", "pointer to robust list head"},
                        size_ptr{"sizep", "pointer to robust list head size",
                                ItemType::PARAM_IN_OUT} {
                setReturnItem(result);
                setParameters(thread_id, list_head, size_ptr);
                list_head.setBase(Base::HEX);
        }
 
        item::ThreadIDItem thread_id;
        /*
         * This points to `struct robust_list_head*` defined in futex.h. It
         * could be fully modeled, but since this is so low-level and exotic I
         * believe there is little value in this at this point.
         */
        item::PointerToScalar<ForeignPtr> list_head;
        item::PointerToScalar<size_t> size_ptr;
        item::SuccessResult result;
};
 
struct CLUES_API SetRobustListSystemCall :
                public SystemCall {
 
        SetRobustListSystemCall() :
                        SystemCall{SystemCallNr::SET_ROBUST_LIST},
                        list_head{"head", "pointer to robust list head"},
                        size{"size", "robust list size"} {
                setReturnItem(result);
                setParameters(list_head, size);
        }
 
        item::GenericPointerValue list_head;
        item::SizeValue size;
        item::SuccessResult result;
};


struct CLUES_API FutexSystemCall :
                public SystemCall {
 
        FutexSystemCall() :
                        SystemCall{SystemCallNr::FUTEX},
                        futex_addr{"addr", "pointer to futex word"},
                        result{item::SuccessResult{}} {
                /*
                 * minimal default setup, the actual parameters and return
                 * values are setup in the member functions in a
                 * context-sensitive manner.
                 */
                setReturnItem(*result);
                setParameters(futex_addr, operation);
        }
 
        /* fixed parameters */
 
        // this points to a 32-bit value which is operated on
        item::GenericPointerValue futex_addr;
        item::FutexOperation operation;
 
        /* context-dependent parameters */

        std::optional<item::Uint32Value> value;
        std::optional<item::Uint32Value> wake_count;
        std::optional<item::SignalNumber> fd_sig;
        std::optional<item::TimeSpecParameter> timeout;
        std::optional<item::GenericPointerValue> futex2_addr;
        std::optional<item::Uint32Value> requeue_value;
        std::optional<item::Uint32Value> requeue_limit;
        std::optional<item::Uint32Value> wake_count2;
        std::optional<item::FutexWakeOperation> wake_op;
        std::optional<item::GenericPointerValue> bitset;
 
        /* context-dependent return values */

        std::optional<item::ReturnValue> num_woken_up;
        std::optional<item::FileDescriptor> new_fd;
        std::optional<item::SuccessResult> result;
 
protected: // functions
 
        bool check2ndPass(const Tracee&) override;
 
        void prepareNewSystemCall() override;
 
        void updateFDTracking(const Tracee &proc) override;
};
 
} // end ns