bytemark/flexnbd-c
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
905d66af77880fce3cfc02fd71e11abc9480852b
flexnbd-c/src/client.h

69 lines
1.8 KiB
C
Raw Normal View History

Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
#ifndef CLIENT_H
#define CLIENT_H
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
#include <signal.h>
#include <time.h>
listen: Turn off CLIENT_MAX_WAIT_SECS The idea behind this feature was to avoid the client thread in a listen server getting stuck forever if the mirroring thread in the source died. However, it breaks any sane implementation of max_Bps in that thread, and there are lingering concerns over how it might operate under normal conditions anyway. Specifically, if iterating over the bitmap takes a long time, or even just reading the requisite 8MB from the disc in order to send it, then the 5-second timeout could be hit, causing mirroring to fail unnecessarily.
2013-08-14 16:09:55 +01:00
#ifdef HAS_LISTEN_TIMEOUT
connect failure scenarios
2012-06-22 10:05:41 +01:00
/** CLIENT_MAX_WAIT_SECS
* This is the length of time an inbound migration will wait for a fresh
* write before assuming the source has Gone Away. Note: it is *not*
* the time from one write to the next, it is the gap between the end of
* one write and the start of the next.
*/
Backed out changeset e58ff57b5e2d Slows tests down
2013-08-09 17:06:56 +01:00
#define CLIENT_MAX_WAIT_SECS 5
connect failure scenarios
2012-06-22 10:05:41 +01:00
listen: Turn off CLIENT_MAX_WAIT_SECS The idea behind this feature was to avoid the client thread in a listen server getting stuck forever if the mirroring thread in the source died. However, it breaks any sane implementation of max_Bps in that thread, and there are lingering concerns over how it might operate under normal conditions anyway. Specifically, if iterating over the bitmap takes a long time, or even just reading the requisite 8MB from the disc in order to send it, then the 5-second timeout could be hit, causing mirroring to fail unnecessarily.
2013-08-14 16:09:55 +01:00
#endif
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
/** CLIENT_HANDLER_TIMEOUT
* This is the length of time (in seconds) any request can be outstanding for.
* If we spend longer than this in a request, the whole server is killed.
*/
#define CLIENT_HANDLER_TIMEOUT 120
/** CLIENT_KILLSWITCH_SIGNAL
* The signal number we use to kill the server when *any* killswitch timer
* fires. We don't actually need to install a signal handler for it, the default
* behaviour is perfectly fine.
*/
#define CLIENT_KILLSWITCH_SIGNAL ( SIGRTMIN + 1 )
Audit client connections on acl update
2012-06-08 18:03:41 +01:00
Renamed struct client_params to struct client
2012-06-06 11:33:17 +01:00
struct client {
Removed proxying completely and fixed the pthread_join bug revealed in the process
2012-06-12 15:08:07 +01:00
/* When we call pthread_join, if the thread is already dead
* we can get an ESRCH. Since we have no other way to tell
* if that ESRCH is from a dead thread or a thread that never
* existed, we use a `stopped` flag to indicate a thread which
* did exist, but went away. Only check this after a
* pthread_join call.
*/
int stopped;
Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
int socket;
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
int fileno;
char* mapped;
Add stop signals to client threads
2012-06-07 11:44:19 +01:00
struct self_pipe * stop_signal;
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
struct server* serve; /* FIXME: remove above duplication */
Add listen mode
2012-06-21 18:01:50 +01:00
Handle a failed disconnect correctly If the sender disconnects its socket before sending the disconnect message, the destination should restart the migration process. This patch makes sure that happens.
2012-07-12 09:39:39 +01:00
/* Have we seen a REQUEST_DISCONNECT message? */
int disconnect;
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
flexnbd: Make the killswitch runtime-selectable We're not actually using it in production right now because it doesn't shut its sockets down cleanly enough. This is a better option than reverting the functionality or keeping production downgraded until we sort out a handler that cleanly closes the sockets.
2013-07-03 09:56:35 +01:00
/* kill the whole server if a request has been outstanding too long,
* assuming use_killswitch is set in serve
*/
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
timer_t killswitch;
Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
};
void* client_serve(void* client_uncast);
Add stop signals to client threads
2012-06-07 11:44:19 +01:00
struct client * client_create( struct server * serve, int socket );
void client_destroy( struct client * client );
void client_signal_stop( struct client * client );
Split client-specific code into client.{c,h}
2012-06-06 11:27:52 +01:00
#endif
serve: Add a killswitch that causes the server to uncleanly exit on hang We define a hang as 120 seconds for now; that should be OK (famous last words). When I say unclean, I mean it; the control socket is left hanging around too. This is a workaround for the fact that the client can hang the whole server by sending a write request header specifying > 0 bytes, then uncleanly going away. On the server side, we acquire the IO mutex, and then try to read > 0 bytes from the socket; the data never arrives, and when the client reconnects, its requests never get a response (since we're waiting on that mutex). Getting rid of that mutex (which isn't actually needed, except for migration) would be better.
2013-06-06 14:16:20 +01:00
Reference in New Issue Copy Permalink