X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=monitor.c;h=4c79ce23b4308b9119f6333d1ea6aac53ac8b614;hb=2d2b0eb7b9d5603edb2e41e2c2860042fbbe8c92;hp=3cb421409ffd0105e550865f2287941c9577a797;hpb=2b60d2890faa8b3dc361a163ea745380c1305c96;p=thirdparty%2Fmdadm.git

diff --git a/monitor.c b/monitor.c
index 3cb42140..4c79ce23 100644
--- a/monitor.c
+++ b/monitor.c
@@ -42,11 +42,11 @@ static void add_fd(fd_set *fds, int *maxfd, int fd)
 	if (fd < 0)
 		return;
 	if (fstat(fd, &st) == -1) {
-		dprintf("%s: Invalid fd %d\n", __func__, fd);
+		dprintf("Invalid fd %d\n", fd);
 		return;
 	}
 	if (st.st_nlink == 0) {
-		dprintf("%s: fd %d was deleted\n", __func__, fd);
+		dprintf("fd %d was deleted\n", fd);
 		return;
 	}
 	if (fd > *maxfd)
@@ -75,18 +75,20 @@ static int read_attr(char *buf, int len, int fd)
 	return n;
 }
 
-static unsigned long long read_resync_start(int fd)
+static void read_resync_start(int fd, unsigned long long *v)
 {
 	char buf[30];
 	int n;
 
 	n = read_attr(buf, 30, fd);
-	if (n <= 0)
-		return 0;
+	if (n <= 0) {
+		dprintf("Failed to read resync_start (%d)\n", fd);
+		return;
+	}
 	if (strncmp(buf, "none", 4) == 0)
-		return MaxSector;
+		*v = MaxSector;
 	else
-		return strtoull(buf, NULL, 10);
+		*v = strtoull(buf, NULL, 10);
 }
 
 static unsigned long long read_sync_completed(int fd)
@@ -231,31 +233,43 @@ static int read_and_act(struct active_array *a)
 	struct mdinfo *mdi;
 	int ret = 0;
 	int count = 0;
+	struct timeval tv;
 
 	a->next_state = bad_word;
 	a->next_action = bad_action;
 
 	a->curr_state = read_state(a->info.state_fd);
 	a->curr_action = read_action(a->action_fd);
-	a->info.resync_start = read_resync_start(a->resync_start_fd);
+	if (a->curr_state != clear)
+		/*
+		 * In "clear" state, resync_start may wrongly be set to "0"
+		 * when the kernel called md_clean but didn't remove the
+		 * sysfs attributes yet
+		 */
+		read_resync_start(a->resync_start_fd, &a->info.resync_start);
 	sync_completed = read_sync_completed(a->sync_completed_fd);
 	for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
 		mdi->next_state = 0;
 		mdi->curr_state = 0;
 		if (mdi->state_fd >= 0) {
-			mdi->recovery_start = read_resync_start(mdi->recovery_fd);
+			read_resync_start(mdi->recovery_fd,
+					  &mdi->recovery_start);
 			mdi->curr_state = read_dev_state(mdi->state_fd);
 		}
 	}
 
-	if (a->curr_state > inactive &&
-	    a->prev_state == inactive) {
-		/* array has been started
-		 * possible that container operation has to be completed
-		 */
-		a->container->ss->set_array_state(a, 0);
-	}
-	if (a->curr_state <= inactive &&
+	gettimeofday(&tv, NULL);
+	dprintf("(%d): %ld.%06ld state:%s prev:%s action:%s prev: %s start:%llu\n",
+		a->info.container_member,
+		tv.tv_sec, tv.tv_usec,
+		array_states[a->curr_state],
+		array_states[a->prev_state],
+		sync_actions[a->curr_action],
+		sync_actions[a->prev_action],
+		a->info.resync_start
+		);
+
+	if ((a->curr_state == bad_word || a->curr_state <= inactive) &&
 	    a->prev_state > inactive) {
 		/* array has been stopped */
 		a->container->ss->set_array_state(a, 1);
@@ -278,8 +292,7 @@ static int read_and_act(struct active_array *a)
 		a->container->ss->set_array_state(a, 1);
 	}
 	if (a->curr_state == active ||
-	    a->curr_state == suspended ||
-	    a->curr_state == bad_word)
+	    a->curr_state == suspended)
 		ret |= ARRAY_DIRTY;
 	if (a->curr_state == readonly) {
 		/* Well, I'm ready to handle things.  If readonly
@@ -407,22 +420,25 @@ static int read_and_act(struct active_array *a)
 	if (sync_completed > a->last_checkpoint)
 		a->last_checkpoint = sync_completed;
 
+	if (sync_completed >= a->info.component_size)
+		a->last_checkpoint = 0;
+
 	a->container->ss->sync_metadata(a->container);
-	dprintf("%s(%d): state:%s action:%s next(", __func__, a->info.container_member,
+	dprintf("(%d): state:%s action:%s next(", a->info.container_member,
 		array_states[a->curr_state], sync_actions[a->curr_action]);
 
 	/* Effect state changes in the array */
 	if (a->next_state != bad_word) {
-		dprintf(" state:%s", array_states[a->next_state]);
+		dprintf_cont(" state:%s", array_states[a->next_state]);
 		write_attr(array_states[a->next_state], a->info.state_fd);
 	}
 	if (a->next_action != bad_action) {
 		write_attr(sync_actions[a->next_action], a->action_fd);
-		dprintf(" action:%s", sync_actions[a->next_action]);
+		dprintf_cont(" action:%s", sync_actions[a->next_action]);
 	}
 	for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
 		if (mdi->next_state & DS_UNBLOCK) {
-			dprintf(" %d:-blocked", mdi->disk.raid_disk);
+			dprintf_cont(" %d:-blocked", mdi->disk.raid_disk);
 			write_attr("-blocked", mdi->state_fd);
 		}
 
@@ -435,7 +451,7 @@ static int read_and_act(struct active_array *a)
 			 */
 			remove_result = write_attr("remove", mdi->state_fd);
 			if (remove_result > 0) {
-				dprintf(" %d:removed", mdi->disk.raid_disk);
+				dprintf_cont(" %d:removed", mdi->disk.raid_disk);
 				close(mdi->state_fd);
 				close(mdi->recovery_fd);
 				mdi->state_fd = -1;
@@ -444,10 +460,10 @@ static int read_and_act(struct active_array *a)
 		}
 		if (mdi->next_state & DS_INSYNC) {
 			write_attr("+in_sync", mdi->state_fd);
-			dprintf(" %d:+in_sync", mdi->disk.raid_disk);
+			dprintf_cont(" %d:+in_sync", mdi->disk.raid_disk);
 		}
 	}
-	dprintf(" )\n");
+	dprintf_cont(" )\n");
 
 	/* move curr_ to prev_ */
 	a->prev_state = a->curr_state;
@@ -618,10 +634,17 @@ static int wait_and_act(struct supertype *container, int nowait)
 		monitor_loop_cnt |= 1;
 		rv = pselect(maxfd+1, NULL, NULL, &rfds, &ts, &set);
 		monitor_loop_cnt += 1;
-		if (rv == -1 && errno == EINTR)
-			rv = 0;
+		if (rv == -1) {
+			if (errno == EINTR) {
+				rv = 0;
+				dprintf("monitor: caught signal\n");
+			} else
+				dprintf("monitor: error %d in pselect\n",
+					errno);
+		}
 		#ifdef DEBUG
-		dprint_wake_reasons(&rfds);
+		else
+			dprint_wake_reasons(&rfds);
 		#endif
 		container->retry_soon = 0;
 	}