/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2010, Michael Lotz, mmlr@mlotz.ch.
 * Distributed under the terms of the MIT License.
 */
#ifndef VFS_TRACING_H
#define VFS_TRACING_H


#include <fs/fd.h>
#include <tracing.h>
#include <vfs.h>


// #pragma mark - File Descriptor Tracing


#if FILE_DESCRIPTOR_TRACING

namespace FileDescriptorTracing {


class FDTraceEntry
        : public TRACE_ENTRY_SELECTOR(FILE_DESCRIPTOR_TRACING_STACK_TRACE) {
public:
        FDTraceEntry(file_descriptor* descriptor)
                :
                TraceEntryBase(FILE_DESCRIPTOR_TRACING_STACK_TRACE, 0, true),
                fDescriptor(descriptor),
                fReferenceCount(descriptor->ref_count)
        {
        }

protected:
        file_descriptor*                fDescriptor;
        int32                                   fReferenceCount;
};


class NewFD : public FDTraceEntry {
public:
        NewFD(io_context* context, int fd, file_descriptor* descriptor)
                :
                FDTraceEntry(descriptor),
                fContext(context),
                fFD(fd)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd new:     descriptor: %p (%" B_PRId32 "), context: %p, "
                        "fd: %d", fDescriptor, fReferenceCount, fContext, fFD);
        }

private:
        io_context*     fContext;
        int                     fFD;
};


class PutFD : public FDTraceEntry {
public:
        PutFD(file_descriptor* descriptor)
                :
                FDTraceEntry(descriptor)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd put:     descriptor: %p (%" B_PRId32 ")", fDescriptor,
                        fReferenceCount);
        }
};


class GetFD : public FDTraceEntry {
public:
        GetFD(io_context* context, int fd, file_descriptor* descriptor)
                :
                FDTraceEntry(descriptor),
                fContext(context),
                fFD(fd)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd get:     descriptor: %p (%" B_PRId32 "), context: %p, "
                        "fd: %d", fDescriptor, fReferenceCount, fContext, fFD);
        }

private:
        io_context*     fContext;
        int                     fFD;
};


class RemoveFD : public FDTraceEntry {
public:
        RemoveFD(io_context* context, int fd, file_descriptor* descriptor)
                :
                FDTraceEntry(descriptor),
                fContext(context),
                fFD(fd)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd remove:  descriptor: %p (%" B_PRId32 "), context: %p, "
                        "fd: %d", fDescriptor, fReferenceCount, fContext, fFD);
        }

private:
        io_context*     fContext;
        int                     fFD;
};


class Dup2FD : public FDTraceEntry {
public:
        Dup2FD(io_context* context, int oldFD, int newFD)
                :
                FDTraceEntry(context->fds[oldFD]),
                fContext(context),
                fEvictedDescriptor(context->fds[newFD]),
                fEvictedReferenceCount(
                        fEvictedDescriptor != NULL ? fEvictedDescriptor->ref_count : 0),
                fOldFD(oldFD),
                fNewFD(newFD)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd dup2:    descriptor: %p (%" B_PRId32 "), context: %p, "
                        "fd: %d -> %d, evicted: %p (%" B_PRId32 ")", fDescriptor,
                        fReferenceCount, fContext, fOldFD, fNewFD, fEvictedDescriptor,
                        fEvictedReferenceCount);
        }

private:
        io_context*                     fContext;
        file_descriptor*        fEvictedDescriptor;
        int32                           fEvictedReferenceCount;
        int                                     fOldFD;
        int                                     fNewFD;
};


class InheritFD : public FDTraceEntry {
public:
        InheritFD(io_context* context, int fd, file_descriptor* descriptor,
                io_context* parentContext)
                :
                FDTraceEntry(descriptor),
                fContext(context),
                fParentContext(parentContext),
                fFD(fd)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("fd inherit: descriptor: %p (%" B_PRId32 "), context: %p, "
                        "fd: %d, parentContext: %p", fDescriptor, fReferenceCount, fContext,
                        fFD, fParentContext);
        }

private:
        io_context*     fContext;
        io_context*     fParentContext;
        int                     fFD;
};


}       // namespace FileDescriptorTracing

#       define TFD(x)   new(std::nothrow) FileDescriptorTracing::x

#else
#       define TFD(x)
#endif  // FILE_DESCRIPTOR_TRACING


// #pragma mark - IO Context Tracing



#if IO_CONTEXT_TRACING

namespace IOContextTracing {


class IOContextTraceEntry : public AbstractTraceEntry {
public:
        IOContextTraceEntry(io_context* context)
                :
                fContext(context)
        {
#if IO_CONTEXT_TRACING_STACK_TRACE
                fStackTrace = capture_tracing_stack_trace(
                        IO_CONTEXT_TRACING_STACK_TRACE, 0, false);
#endif
        }

#if IO_CONTEXT_TRACING_STACK_TRACE
        virtual void DumpStackTrace(TraceOutput& out)
        {
                out.PrintStackTrace(fStackTrace);
        }
#endif

protected:
        io_context*                             fContext;
#if IO_CONTEXT_TRACING_STACK_TRACE
        tracing_stack_trace*    fStackTrace;
#endif
};


class NewIOContext : public IOContextTraceEntry {
public:
        NewIOContext(io_context* context, io_context* parentContext)
                :
                IOContextTraceEntry(context),
                fParentContext(parentContext)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("iocontext new:    context: %p, parent: %p", fContext,
                        fParentContext);
        }

private:
        io_context*     fParentContext;
};


class FreeIOContext : public IOContextTraceEntry {
public:
        FreeIOContext(io_context* context)
                :
                IOContextTraceEntry(context)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("iocontext free:   context: %p", fContext);
        }
};


class ResizeIOContext : public IOContextTraceEntry {
public:
        ResizeIOContext(io_context* context, uint32 newTableSize)
                :
                IOContextTraceEntry(context),
                fOldTableSize(context->table_size),
                fNewTableSize(newTableSize)
        {
                Initialized();
        }

        virtual void AddDump(TraceOutput& out)
        {
                out.Print("iocontext resize: context: %p, size: %" B_PRIu32     " -> %"
                        B_PRIu32, fContext, fOldTableSize, fNewTableSize);
        }

private:
        uint32  fOldTableSize;
        uint32  fNewTableSize;
};


}       // namespace IOContextTracing

#       define TIOC(x)  new(std::nothrow) IOContextTracing::x

#else
#       define TIOC(x)
#endif  // IO_CONTEXT_TRACING


#endif // VFS_TRACING_H