lock_client.h

   1 // lock client interface.
   2
   3 #ifndef lock_client_h
   4 #define lock_client_h
   5
   6 #ifdef __cplusplus
   7
   8 #include "types.h"
   9 #include "lock_protocol.h"
  10 #include "rpc/fifo.h"
  11 #include "rsm_client.h"
  12 #include "maybe.h"
  13
  14 class lock_release_user {
  15     public:
  16         virtual void dorelease(lock_protocol::lockid_t) = 0;
  17         virtual ~lock_release_user() {}
  18 };
  19
  20 class lock_state {
  21 public:
  22     enum {
  23         none = 0,
  24         retrying,
  25         free,
  26         locked,
  27         acquiring,
  28         releasing
  29     } state = none;
  30     std::thread::id held_by;
  31     std::list<thread::id> wanted_by;
  32     std::mutex m;
  33     std::map<thread::id, cond> c;
  34     lock_protocol::xid_t xid;
  35     void wait(lock & mutex_lock);
  36     void signal();
  37     void signal(thread::id who);
  38 };
  39
  40 typedef std::map<lock_protocol::lockid_t, lock_state> lock_map;
  41
  42 // Clients that caches locks.  The server can revoke locks using
  43 // lock_revoke_server.
  44 class lock_client {
  45     private:
  46         unique_ptr<rpcs> rlsrpc;
  47         thread releaser_thread;
  48         unique_ptr<rsm_client> rsmc;
  49         lock_release_user *lu;
  50         in_port_t rlock_port;
  51         string hostname;
  52         string id;
  53         std::mutex xid_mutex;
  54         lock_protocol::xid_t next_xid;
  55         fifo<maybe<lock_protocol::lockid_t>> release_fifo;
  56         std::mutex lock_table_lock;
  57         lock_map lock_table;
  58         lock_state & get_lock_state(lock_protocol::lockid_t lid);
  59     public:
  60         lock_client(string xdst, lock_release_user *l = 0);
  61         ~lock_client();
  62         lock_protocol::status acquire(lock_protocol::lockid_t);
  63         lock_protocol::status release(lock_protocol::lockid_t);
  64         void releaser();
  65         rlock_protocol::status revoke_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
  66         rlock_protocol::status retry_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
  67 };
  68
  69 #endif // C++
  70
  71 #ifdef __cplusplus
  72 extern "C" {
  73 #endif
  74
  75 struct _t4_lock_client;
  76 typedef struct _t4_lock_client t4_lock_client;
  77
  78 typedef enum {
  79     T4_OK,
  80     T4_RETRY,
  81     T4_RPCERR,
  82     T4_NOENT,
  83     T4_IOERR
  84 } t4_xxstatus;
  85
  86 typedef int t4_status;
  87
  88 typedef const char * t4_lockid_t;
  89
  90 t4_lock_client *t4_lock_client_new(const char *dst);
  91 void t4_lock_client_delete(t4_lock_client *);
  92 t4_status t4_lock_client_acquire(t4_lock_client *, t4_lockid_t);
  93 t4_status t4_lock_client_release(t4_lock_client *, t4_lockid_t);
  94
  95 #ifdef __cplusplus
  96 }
  97 #endif
  98
  99 #endif