IpcIoFile.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_DISKIO_IPCIO_IPCIOFILE_H
#define SQUID_SRC_DISKIO_IPCIO_IPCIOFILE_H
 
#include "base/AsyncCall.h"
#include "cbdata.h"
#include "DiskIO/DiskFile.h"
#include "DiskIO/IORequestor.h"
#include "ipc/forward.h"
#include "ipc/mem/Page.h"
#include "SquidString.h"
#include <list>
#include <map>
#include <memory>
 
namespace Ipc
{
class FewToFewBiQueue;
} // Ipc
 
// TODO: expand to all classes
namespace IpcIo
{
 
typedef enum { cmdNone, cmdOpen, cmdRead, cmdWrite } Command;
 
std::ostream &operator <<(std::ostream &, Command);
 
} // namespace IpcIo
 
class IpcIoMsg
{
public:
    IpcIoMsg();
 
    void stat(std::ostream &);
 
public:
    unsigned int requestId; 
 
    off_t offset;
    size_t len;
    Ipc::Mem::PageId page;
    pid_t workerPid; 
 
    IpcIo::Command command; 
    struct timeval start; 
 
    int xerrno; 
};
 
class IpcIoPendingRequest;
 
class IpcIoFile: public DiskFile
{
    CBDATA_CLASS(IpcIoFile);
 
public:
    typedef RefCount<IpcIoFile> Pointer;
 
    IpcIoFile(char const *aDb);
    ~IpcIoFile() override;
 
    /* DiskFile API */
    void configure(const Config &cfg) override;
    void open(int flags, mode_t mode, RefCount<IORequestor> callback) override;
    void create(int flags, mode_t mode, RefCount<IORequestor> callback) override;
    void read(ReadRequest *) override;
    void write(WriteRequest *) override;
    void close() override;
    bool error() const override;
    int getFD() const override;
    bool canRead() const override;
    bool canWrite() const override;
    bool ioInProgress() const override;
 
    static void HandleOpenResponse(const Ipc::StrandMessage &);
 
    static void HandleNotification(const Ipc::TypedMsgHdr &msg);
 
    static void StatQueue(std::ostream &);
 
    DiskFile::Config config; 
 
protected:
    friend class IpcIoPendingRequest;
    void openCompleted(const Ipc::StrandMessage *);
    void readCompleted(ReadRequest *readRequest, IpcIoMsg *const response);
    void writeCompleted(WriteRequest *writeRequest, const IpcIoMsg *const response);
    bool canWait() const;
 
private:
    void trackPendingRequest(const unsigned int id, IpcIoPendingRequest *const pending);
    void push(IpcIoPendingRequest *const pending);
    IpcIoPendingRequest *dequeueRequest(const unsigned int requestId);
 
    size_t pendingRequests() const { return olderRequests->size() + newerRequests->size(); }
 
    static void Notify(const int peerId);
 
    static void OpenTimeout(void *const param);
    static void CheckTimeouts(void *const param);
    void checkTimeouts();
    void scheduleTimeoutCheck();
 
    static void HandleResponses(const char *const when);
    void handleResponse(IpcIoMsg &ipcIo);
 
    static void DiskerHandleMoreRequests(void*);
    static void DiskerHandleRequests();
    static void DiskerHandleRequest(const int workerId, IpcIoMsg &ipcIo);
    static bool WaitBeforePop();
 
    static void HandleMessagesAtStart();
 
private:
    const String dbName; 
    const pid_t myPid; 
    int diskId; 
    RefCount<IORequestor> ioRequestor;
 
    bool error_; 
 
    unsigned int lastRequestId; 
 
    typedef std::map<unsigned int, IpcIoPendingRequest*> RequestMap;
    RequestMap requestMap1; 
    RequestMap requestMap2; 
    RequestMap *olderRequests; 
    RequestMap *newerRequests; 
    bool timeoutCheckScheduled; 
 
    static const double Timeout; 
 
    typedef std::list<Pointer> IpcIoFileList;
    static IpcIoFileList WaitingForOpen; 
 
    typedef std::map<int, IpcIoFile*> IpcIoFilesMap;
    static IpcIoFilesMap IpcIoFiles;
 
    typedef Ipc::FewToFewBiQueue Queue;
    static std::unique_ptr<Queue> queue; 
 
    static bool DiskerHandleMoreRequestsScheduled;
};
 
class IpcIoPendingRequest
{
public:
    IpcIoPendingRequest(const IpcIoFile::Pointer &aFile);
 
    void completeIo(IpcIoMsg *const response);
 
public:
    const IpcIoFile::Pointer file; 
    ReadRequest *readRequest; 
    WriteRequest *writeRequest; 
 
    CodeContext::Pointer codeContext; 
 
private:
    IpcIoPendingRequest(const IpcIoPendingRequest &d); // not implemented
    IpcIoPendingRequest &operator =(const IpcIoPendingRequest &d); // ditto
};
 
#endif /* SQUID_SRC_DISKIO_IPCIO_IPCIOFILE_H */