RPC procedures are now identified via a struct containing a string name.
[invirt/third/libt4.git] / 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