diff options
Diffstat (limited to 'src/libostree/ostree-sysroot-deploy.c')
-rw-r--r-- | src/libostree/ostree-sysroot-deploy.c | 68 |
1 files changed, 67 insertions, 1 deletions
diff --git a/src/libostree/ostree-sysroot-deploy.c b/src/libostree/ostree-sysroot-deploy.c index c4ae86d5..6ee62410 100644 --- a/src/libostree/ostree-sysroot-deploy.c +++ b/src/libostree/ostree-sysroot-deploy.c @@ -26,6 +26,7 @@ #include <sys/statvfs.h> #include <sys/socket.h> #include <sys/ioctl.h> +#include <stdbool.h> #include <sys/poll.h> #include <linux/fs.h> #include <err.h> @@ -1557,6 +1558,39 @@ typedef struct { guint64 extra_syncfs_msec; } SyncStats; +typedef struct { + int ref_count; /* atomic */ + bool success; + GMutex mutex; + GCond cond; +} SyncData; + +static void +sync_data_unref (SyncData *data) +{ + if (!g_atomic_int_dec_and_test (&data->ref_count)) + return; + g_mutex_clear (&data->mutex); + g_cond_clear (&data->cond); + g_free (data); +} + +// An asynchronous sync() call. See below. +static void * +sync_in_thread (void *ptr) +{ + SyncData *syncdata = ptr; + // Ensure that the caller is blocked waiting + g_mutex_lock (&syncdata->mutex); + sync (); + // Signal success + syncdata->success = true; + g_cond_broadcast (&syncdata->cond); + g_mutex_unlock (&syncdata->mutex); + sync_data_unref (syncdata); + return NULL; +} + /* First, sync the root directory as well as /var and /boot which may * be separate mount points. Then *in addition*, do a global * `sync()`. @@ -1589,9 +1623,41 @@ full_system_sync (OstreeSysroot *self, * actually get error codes out of that API, and we more clearly * delineate what we actually want to sync in the future when this * global sync call is removed. + * + * Due to https://bugzilla.redhat.com/show_bug.cgi?id=2003532 which is + * a bug in the interaction between Ceph and systemd, we have a capped + * timeout of 5s on the sync here. In general, we don't actually want + * to "own" flushing data on *all* mounted filesystems as part of + * our process. Again, we're only keeping the `sync` here out of + * conservatisim. We could likely just remove it and e.g. systemd + * would take care of sync as part of unmounting individual filesystems. */ start_msec = g_get_monotonic_time () / 1000; - sync (); + if (!(self->opt_flags & OSTREE_SYSROOT_GLOBAL_OPT_SKIP_SYNC)) + { + SyncData *syncdata = g_new (SyncData, 1); + syncdata->ref_count = 2; // One for us, one for thread + syncdata->success = FALSE; + g_mutex_init (&syncdata->mutex); + g_cond_init (&syncdata->cond); + g_mutex_lock (&syncdata->mutex); + GThread *worker = g_thread_new ("ostree sync", sync_in_thread, syncdata); + // Wait up to 5 seconds for sync() to finish + gint64 end_time = g_get_monotonic_time () + (5 * G_TIME_SPAN_SECOND); + while (!syncdata->success) + { + if (!g_cond_wait_until (&syncdata->cond, &syncdata->mutex, end_time)) + break; + } + g_mutex_unlock (&syncdata->mutex); + sync_data_unref (syncdata); + // We can't join the thread here, for two reasons. First, the whole + // point here is to avoid blocking on `sync`. The other reason is + // today there is no return value on success from `sync`, so there's + // no point to joining the thread even if we had a nonblocking mechanism + // to do so. + g_thread_unref (worker); + } end_msec = g_get_monotonic_time () / 1000; out_stats->extra_syncfs_msec = (end_msec - start_msec); |