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
  13 class lock_release_user {
  14     public:
  15         virtual void dorelease(lock_protocol::lockid_t) = 0;
  16         virtual ~lock_release_user() {}
  17 };
  18
  19 class lock_state {
  20 public:
  21     enum {
  22         none = 0,
  23         retrying,
  24         free,
  25         locked,
  26         acquiring,
  27         releasing
  28     } state = none;
  29     thread::id held_by;
  30     list<thread::id> wanted_by;
  31     mutex m;
  32     map<thread::id, cond> c;
  33     lock_protocol::xid_t xid;
  34     void wait(lock & mutex_lock);
  35     void signal();
  36     void signal(thread::id who);
  37 };
  38
  39 typedef map<lock_protocol::lockid_t, lock_state> lock_map;
  40
  41 // Clients that caches locks.  The server can revoke locks using
  42 // lock_revoke_server.
  43 class lock_client {
  44     private:
  45         unique_ptr<rpcc> cl;
  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         mutex xid_mutex;
  54         lock_protocol::xid_t next_xid;
  55         fifo<lock_protocol::lockid_t> release_fifo;
  56         mutex lock_table_lock;
  57         lock_map lock_table;
  58         lock_state &get_lock_state(lock_protocol::lockid_t lid);
  59     public:
  60         static in_port_t last_port;
  61         lock_client(string xdst, lock_release_user *l = 0);
  62         ~lock_client() {}
  63         lock_protocol::status acquire(lock_protocol::lockid_t);
  64         lock_protocol::status release(lock_protocol::lockid_t);
  65         int stat(lock_protocol::lockid_t);
  66         void releaser();
  67         rlock_protocol::status revoke_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
  68         rlock_protocol::status retry_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
  69 };
  70
  71 #endif // C++
  72
  73 extern "C" {
  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 t4_status t4_lock_client_stat(t4_lock_client *, t4_lockid_t);
  95
  96 }
  97
  98 #endif