Rename serve->has_control to serve->success.

This makes the use of this variable to signal an unexpected SIGTERM
while migrating less confusing.

src/control.c

@@ -235,7 +235,7 @@ void * control_runner( void * control_uncast )
 	control_serve( control );
 
 	control_cleanup( control, 0 );
-	return NULL;
+	pthread_exit( NULL );
 }
 
 

src/flexnbd.c

@@ -150,8 +150,10 @@ void flexnbd_stop_control( struct flexnbd * flexnbd )
 	NULLCHECK( flexnbd->control );
 
 	control_signal_close( flexnbd->control );
-	FATAL_UNLESS( 0 == pthread_join( flexnbd->control->thread, NULL ),
-			"Failed joining the control thread" );
+	pthread_t tid = flexnbd->control->thread;
+	FATAL_UNLESS( 0 == pthread_join( tid, NULL ),
+		      "Failed joining the control thread" );
+	debug( "Control thread %p pthread_join returned", tid );
 }
 
 
@@ -240,6 +242,7 @@ int flexnbd_serve( struct flexnbd * flexnbd )
 	}
 
 	success = do_serve( flexnbd->serve );
+	debug("do_serve success is %d", success );
 
 	if ( flexnbd->control ) {
 		debug( "Stopping control thread" );

src/ioutil.c

@@ -11,6 +11,7 @@
 #include "util.h"
 #include "bitset.h"
 
+
 int build_allocation_map(struct bitset_mapping* allocation_map, int fd)
 {
 	/* break blocking ioctls down */
@@ -31,31 +32,33 @@ int build_allocation_map(struct bitset_mapping* allocation_map, int fd)
 		unsigned int i;
 
 		fiemap->fm_start = offset;
+
 		fiemap->fm_length = max_length;
-		if (offset + max_length > allocation_map->size)
+		if ( offset + max_length > allocation_map->size ) {
 			fiemap->fm_length = allocation_map->size-offset;
+		}
+
 		fiemap->fm_flags = FIEMAP_FLAG_SYNC;
 		fiemap->fm_extent_count = max_extents;
 		fiemap->fm_mapped_extents = 0;
 
-		if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0) {
+		if ( ioctl( fd, FS_IOC_FIEMAP, fiemap ) < 0 ) {
 			debug( "Couldn't get fiemap, returning no allocation_map" );
 			free(allocation_map);
-			return NULL;
+			allocation_map = NULL;
+			break;
 		}
-
-		for (i=0;i<fiemap->fm_mapped_extents;i++) {
-			bitset_set_range(
-				allocation_map,
-				fiemap->fm_extents[i].fe_logical,
-				fiemap->fm_extents[i].fe_length
-			);
-			//debug("range from %ld + %ld", fiemap->fm_extents[i].fe_logical, fiemap->fm_extents[i].fe_length);
+		else {
+			for ( i = 0; i < fiemap->fm_mapped_extents; i++ ) {
+				bitset_set_range( allocation_map,
+						  fiemap->fm_extents[i].fe_logical,
+						  fiemap->fm_extents[i].fe_length );
+			}
 		}
 	}
 
 	debug("Successfully built allocation map");
-	return allocation_map;
+	return NULL != allocation_map;
 }
 
 

src/mode.c

@@ -406,6 +406,8 @@ int mode_serve( int argc, char *argv[] )
 	int default_deny = 0; // not on by default
 	int err = 0;
 
+	int success;
+
 	struct flexnbd * flexnbd;
 
 	while (1) {
@@ -427,10 +429,10 @@ int mode_serve( int argc, char *argv[] )
 
 	flexnbd = flexnbd_create_serving( ip_addr, ip_port, file, sock, default_deny, argc - optind, argv + optind, MAX_NBD_CLIENTS );
 	info( "Serving file %s", file );
-	flexnbd_serve( flexnbd );
+	success = flexnbd_serve( flexnbd );
 	flexnbd_destroy( flexnbd );
 
-	return 0;
+	return success ? 0 : 1;
 }
 
 

src/serve.c

@@ -45,13 +45,13 @@ struct server * server_create (
 	int acl_entries,
 	char** s_acl_entries,
 	int max_nbd_clients,
-	int has_control)
+	int success)
 {
 	NULLCHECK( flexnbd );
 	struct server * out;
 	out = xmalloc( sizeof( struct server ) );
 	out->flexnbd = flexnbd;
-	out->has_control = has_control;
+	out->success = success;
 	out->max_nbd_clients = max_nbd_clients;
 	out->nbd_client = xmalloc( max_nbd_clients * sizeof( struct client_tbl_entry ) );
 
@@ -678,23 +678,24 @@ int server_mirror_can_start( struct server *serve )
 }
 
 
-void serve_handle_signal( struct server *params )
+/* Queries to see if we are currently mirroring.  If we are, we need
+ * to communicate that via the process exit status. because otherwise
+ * the supervisor will assume the migration completed.
+ */
+int serve_shutdown_is_graceful( struct server *params )
 {
-	int should_die = 0;
+	int is_mirroring = 0;
 	server_lock_start_mirror( params );
 	{
 		if ( server_is_mirroring( params ) ) {
-			should_die = 1;
+			is_mirroring = 1;
+			warn( "Stop signal received while mirroring." );
 			server_prevent_mirror_start( params );
 		}
 	}
 	server_unlock_start_mirror( params );
 
-	if ( should_die ){
-		fatal( "Stop signal received while mirroring." );
-	} else {
-		server_close_clients( params );
-	}
+	return !is_mirroring;
 }
 
 
@@ -710,6 +711,7 @@ int server_accept( struct server * params )
 	/* We select on this fd to receive OS signals (only a few of
 	 * which we're interested in, see flexnbd.c */
 	int              signal_fd = flexnbd_signal_fd( params->flexnbd );
+	int              should_continue = 1;
 
 	FD_ZERO(&fds);
 	FD_SET(params->server_fd, &fds);
@@ -722,17 +724,15 @@ int server_accept( struct server * params )
 
 	if ( self_pipe_fd_isset( params->close_signal, &fds ) ){
 		server_close_clients( params );
-		return 0;
+		should_continue = 0;
 	}
 
+
 	if ( 0 < signal_fd && FD_ISSET( signal_fd, &fds ) ){
 		debug( "Stop signal received." );
-		serve_handle_signal( params );
-
-		/* serve_handle_signal will fatal() if it has to, so it
-		 * might not return at all.
-		 */
-		return 0;
+		server_close_clients( params );
+		params->success = serve_shutdown_is_graceful( params );
+		should_continue = 0;
 	}
 
 
@@ -747,7 +747,7 @@ int server_accept( struct server * params )
 		accept_nbd_client(params, client_fd, &client_address);
 	}
 
-	return 1;
+	return should_continue;
 }
 
 
@@ -825,13 +825,15 @@ void server_control_arrived( struct server *serve )
 {
 	NULLCHECK( serve );
 
-	if ( !serve->has_control ) {
-		serve->has_control = 1;
+	if ( !serve->success ) {
+		serve->success = 1;
 		serve_signal_close( serve );
 	}
 }
 
 
+void flexnbd_stop_control( struct flexnbd * flexnbd );
+
 /** Closes sockets, frees memory and waits for all client threads to finish */
 void serve_cleanup(struct server* params,
 		int fatal __attribute__ ((unused)) )
@@ -864,7 +866,6 @@ void serve_cleanup(struct server* params,
 	}
 	if ( need_mirror_lock ) { server_unlock_start_mirror( params ); }
 
-
 	for (i=0; i < params->max_nbd_clients; i++) {
 		pthread_t thread_id = params->nbd_client[i].thread;
 
@@ -882,6 +883,15 @@ void serve_cleanup(struct server* params,
 		server_unlock_acl( params );
 	}
 
+	/* if( params->flexnbd ) { */
+	/* 	if ( params->flexnbd->control ) { */
+	/* 		flexnbd_stop_control( params->flexnbd ); */
+	/* 	} */
+	/* 	flexnbd_destroy( params->flexnbd ); */
+	/* } */
+
+	/* server_destroy( params ); */
+
 	debug( "Cleanup done");
 }
 
@@ -889,7 +899,7 @@ void serve_cleanup(struct server* params,
 int server_is_in_control( struct server *serve )
 {
 	NULLCHECK( serve );
-	return serve->has_control;
+	return serve->success;
 }
 
 int server_is_mirroring( struct server * serve )
@@ -911,7 +921,9 @@ void server_abandon_mirror( struct server * serve )
 		 * the next pass.
 		 * */
 		serve->mirror->signal_abandon = 1;
-		pthread_join( serve->mirror_super->thread, NULL );
+		pthread_t tid = serve->mirror_super->thread;
+		pthread_join( tid, NULL );
+		debug( "Mirror thread %p pthread_join returned", tid );
 	}
 }
 
@@ -926,15 +938,15 @@ int do_serve(struct server* params)
 {
 	NULLCHECK( params );
 
-	int has_control;
+	int success;
 
 	error_set_handler((cleanup_handler*) serve_cleanup, params);
 	serve_open_server_socket(params);
 	serve_init_allocation_map(params);
 	serve_accept_loop(params);
-	has_control = params->has_control;
+	success = params->success;
 	serve_cleanup(params, 0);
 
-	return has_control;
+	return success;
 }
 

src/serve.h

@@ -91,8 +91,11 @@ struct server {
 	/* Marker for whether this server has control over the data in
 	 * the file, or if we're waiting to receive it from an inbound
 	 * migration which hasn't yet finished.
+	 *
+	 * It's the value which controls the exit status of a serve or
+	 * listen process.
 	 */
-	int has_control;
+	int success;
 };
 
 struct server * server_create(
@@ -104,7 +107,7 @@ struct server * server_create(
 		int acl_entries,
 		char** s_acl_entries,
 		int max_nbd_clients,
-		int has_control );
+		int success );
 void server_destroy( struct server * );
 int server_is_closed(struct server* serve);
 void server_dirty(struct server *serve, off64_t from, int len);

src/status.c

@@ -9,7 +9,7 @@ struct status * status_create( struct server * serve )
 
 	status = xmalloc( sizeof( struct status ) );
 	status->pid = getpid();
-	status->has_control = serve->has_control;
+	status->has_control = server_is_in_control( serve );
 	status->is_mirroring = NULL != serve->mirror;
 	return status;
 

tests/acceptance/flexnbd.rb

@@ -310,13 +310,14 @@ module FlexNBD
       debug( cmd )
 
       @pid = @executor.run( cmd )
-      start_wait_thread( @pid )
 
       while !File.socket?(ctrl)
         pid, status = Process.wait2(@pid, Process::WNOHANG)
         raise "server did not start (#{cmd})" if pid
         sleep 0.1
       end
+
+      start_wait_thread( @pid )
       at_exit { kill }
     end
     private :run_serve_cmd

tests/acceptance/test_source_error_handling.rb

@@ -20,7 +20,7 @@ class TestSourceErrorHandling < Test::Unit::TestCase
 
 
   def expect_term_during_migration
-    @env.nbd1.can_die(6,9)
+    @env.nbd1.can_die(1,9)
   end