files-backend: add and use files_reflog_path()

Keep repo-related path handling in one place. This will make it easier
to add submodule/multiworktree support later.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/files-backend.c b/refs/files-backend.c
index 3e0bafcaf93cf76582a52d3113b02e6f442c1a56..b0e0df9f668646708ef463921686a40dd8149d17 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -165,7 +165,8 @@ static struct ref_entry *create_dir_entry(struct files_ref_store *ref_store,
                                          const char *dirname, size_t len,
                                          int incomplete);
 static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry);
                                          const char *dirname, size_t len,
                                          int incomplete);
 static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry);

-static int files_log_ref_write(const char *refname, const unsigned char *old_sha1,
+static int files_log_ref_write(struct files_ref_store *refs,
+                              const char *refname, const unsigned char *old_sha1,

                               const unsigned char *new_sha1, const char *msg,
                               int flags, struct strbuf *err);
 
                               const unsigned char *new_sha1, const char *msg,
                               int flags, struct strbuf *err);
 


@@ -1167,6 +1168,18 @@ static const char *files_packed_refs_path(struct files_ref_store *refs)
        return refs->packed_refs_path;
 }
 
        return refs->packed_refs_path;
 }
 

+static void files_reflog_path(struct files_ref_store *refs,
+                             struct strbuf *sb,
+                             const char *refname)
+{
+       if (!refname) {
+               strbuf_git_path(sb, "logs");
+               return;
+       }
+
+       strbuf_git_path(sb, "logs/%s", refname);
+}
+

 /*
  * Get the packed_ref_cache for the specified files_ref_store,
  * creating it if necessary.
 /*
  * Get the packed_ref_cache for the specified files_ref_store,
  * creating it if necessary.


@@ -2313,7 +2326,9 @@ enum {
  * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or
  * REMOVE_EMPTY_PARENTS_REFLOG.
  */
  * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or
  * REMOVE_EMPTY_PARENTS_REFLOG.
  */

-static void try_remove_empty_parents(const char *refname, unsigned int flags)
+static void try_remove_empty_parents(struct files_ref_store *refs,
+                                    const char *refname,
+                                    unsigned int flags)

 {
        struct strbuf buf = STRBUF_INIT;
        struct strbuf sb = STRBUF_INIT;
 {
        struct strbuf buf = STRBUF_INIT;
        struct strbuf sb = STRBUF_INIT;


@@ -2345,7 +2360,7 @@ static void try_remove_empty_parents(const char *refname, unsigned int flags)
                        flags &= ~REMOVE_EMPTY_PARENTS_REF;
 
                strbuf_reset(&sb);
                        flags &= ~REMOVE_EMPTY_PARENTS_REF;
 
                strbuf_reset(&sb);

-               strbuf_git_path(&sb, "logs/%s", buf.buf);
+               files_reflog_path(refs, &sb, buf.buf);

                if ((flags & REMOVE_EMPTY_PARENTS_REFLOG) && rmdir(sb.buf))
                        flags &= ~REMOVE_EMPTY_PARENTS_REFLOG;
        }
                if ((flags & REMOVE_EMPTY_PARENTS_REFLOG) && rmdir(sb.buf))
                        flags &= ~REMOVE_EMPTY_PARENTS_REFLOG;
        }


@@ -2538,15 +2553,15 @@ static int rename_tmp_log_callback(const char *path, void *cb_data)
        }
 }
 
        }
 }
 

-static int rename_tmp_log(const char *newrefname)
+static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)

 {
        struct strbuf path = STRBUF_INIT;
        struct strbuf tmp = STRBUF_INIT;
        struct rename_cb cb;
        int ret;
 
 {
        struct strbuf path = STRBUF_INIT;
        struct strbuf tmp = STRBUF_INIT;
        struct rename_cb cb;
        int ret;
 

-       strbuf_git_path(&path, "logs/%s", newrefname);
-       strbuf_git_path(&tmp, "logs/%s", TMP_RENAMED_LOG);
+       files_reflog_path(refs, &path, newrefname);
+       files_reflog_path(refs, &tmp, TMP_RENAMED_LOG);

        cb.tmp_renamed_log = tmp.buf;
        ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb);
        if (ret) {
        cb.tmp_renamed_log = tmp.buf;
        ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb);
        if (ret) {


@@ -2606,9 +2621,9 @@ static int files_rename_ref(struct ref_store *ref_store,
        int log, ret;
        struct strbuf err = STRBUF_INIT;
 
        int log, ret;
        struct strbuf err = STRBUF_INIT;
 

-       strbuf_git_path(&sb_oldref, "logs/%s", oldrefname);
-       strbuf_git_path(&sb_newref, "logs/%s", newrefname);
-       strbuf_git_path(&tmp_renamed_log, "logs/%s", TMP_RENAMED_LOG);
+       files_reflog_path(refs, &sb_oldref, oldrefname);
+       files_reflog_path(refs, &sb_newref, newrefname);
+       files_reflog_path(refs, &tmp_renamed_log, TMP_RENAMED_LOG);

 
        log = !lstat(sb_oldref.buf, &loginfo);
        if (log && S_ISLNK(loginfo.st_mode)) {
 
        log = !lstat(sb_oldref.buf, &loginfo);
        if (log && S_ISLNK(loginfo.st_mode)) {


@@ -2671,7 +2686,7 @@ static int files_rename_ref(struct ref_store *ref_store,
                }
        }
 
                }
        }
 

-       if (log && rename_tmp_log(newrefname))
+       if (log && rename_tmp_log(refs, newrefname))

                goto rollback;
 
        logmoved = log;
                goto rollback;
 
        logmoved = log;


@@ -2786,10 +2801,15 @@ static int open_or_create_logfile(const char *path, void *cb)
  * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and
  * return -1.
  */
  * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and
  * return -1.
  */

-static int log_ref_setup(const char *refname, int force_create,
+static int log_ref_setup(struct files_ref_store *refs,
+                        const char *refname, int force_create,

                         int *logfd, struct strbuf *err)
 {
                         int *logfd, struct strbuf *err)
 {

-       char *logfile = git_pathdup("logs/%s", refname);
+       struct strbuf logfile_sb = STRBUF_INIT;
+       char *logfile;
+
+       files_reflog_path(refs, &logfile_sb, refname);
+       logfile = strbuf_detach(&logfile_sb, NULL);

 
        if (force_create || should_autocreate_reflog(refname)) {
                if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) {
 
        if (force_create || should_autocreate_reflog(refname)) {
                if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) {


@@ -2839,12 +2859,11 @@ static int files_create_reflog(struct ref_store *ref_store,
                               const char *refname, int force_create,
                               struct strbuf *err)
 {
                               const char *refname, int force_create,
                               struct strbuf *err)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "create_reflog");

        int fd;
 
        int fd;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "create_reflog");
-
-       if (log_ref_setup(refname, force_create, &fd, err))
+       if (log_ref_setup(refs, refname, force_create, &fd, err))

                return -1;
 
        if (fd >= 0)
                return -1;
 
        if (fd >= 0)


@@ -2879,7 +2898,8 @@ static int log_ref_write_fd(int fd, const unsigned char *old_sha1,
        return 0;
 }
 
        return 0;
 }
 

-static int files_log_ref_write(const char *refname, const unsigned char *old_sha1,
+static int files_log_ref_write(struct files_ref_store *refs,
+                              const char *refname, const unsigned char *old_sha1,

                               const unsigned char *new_sha1, const char *msg,
                               int flags, struct strbuf *err)
 {
                               const unsigned char *new_sha1, const char *msg,
                               int flags, struct strbuf *err)
 {


@@ -2888,7 +2908,8 @@ static int files_log_ref_write(const char *refname, const unsigned char *old_sha
        if (log_all_ref_updates == LOG_REFS_UNSET)
                log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;
 
        if (log_all_ref_updates == LOG_REFS_UNSET)
                log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;
 

-       result = log_ref_setup(refname, flags & REF_FORCE_CREATE_REFLOG,
+       result = log_ref_setup(refs, refname,
+                              flags & REF_FORCE_CREATE_REFLOG,

                               &logfd, err);
 
        if (result)
                               &logfd, err);
 
        if (result)


@@ -2902,7 +2923,7 @@ static int files_log_ref_write(const char *refname, const unsigned char *old_sha
                struct strbuf sb = STRBUF_INIT;
                int save_errno = errno;
 
                struct strbuf sb = STRBUF_INIT;
                int save_errno = errno;
 

-               strbuf_git_path(&sb, "logs/%s", refname);
+               files_reflog_path(refs, &sb, refname);

                strbuf_addf(err, "unable to append to '%s': %s",
                            sb.buf, strerror(save_errno));
                strbuf_release(&sb);
                strbuf_addf(err, "unable to append to '%s': %s",
                            sb.buf, strerror(save_errno));
                strbuf_release(&sb);


@@ -2913,7 +2934,7 @@ static int files_log_ref_write(const char *refname, const unsigned char *old_sha
                struct strbuf sb = STRBUF_INIT;
                int save_errno = errno;
 
                struct strbuf sb = STRBUF_INIT;
                int save_errno = errno;
 

-               strbuf_git_path(&sb, "logs/%s", refname);
+               files_reflog_path(refs, &sb, refname);

                strbuf_addf(err, "unable to append to '%s': %s",
                            sb.buf, strerror(save_errno));
                strbuf_release(&sb);
                strbuf_addf(err, "unable to append to '%s': %s",
                            sb.buf, strerror(save_errno));
                strbuf_release(&sb);


@@ -2974,7 +2995,8 @@ static int commit_ref_update(struct files_ref_store *refs,
        files_assert_main_repository(refs, "commit_ref_update");
 
        clear_loose_ref_cache(refs);
        files_assert_main_repository(refs, "commit_ref_update");
 
        clear_loose_ref_cache(refs);

-       if (files_log_ref_write(lock->ref_name, lock->old_oid.hash, sha1,
+       if (files_log_ref_write(refs, lock->ref_name,
+                               lock->old_oid.hash, sha1,

                                logmsg, 0, err)) {
                char *old_msg = strbuf_detach(err, NULL);
                strbuf_addf(err, "cannot update the ref '%s': %s",
                                logmsg, 0, err)) {
                char *old_msg = strbuf_detach(err, NULL);
                strbuf_addf(err, "cannot update the ref '%s': %s",


@@ -3006,8 +3028,9 @@ static int commit_ref_update(struct files_ref_store *refs,
                if (head_ref && (head_flag & REF_ISSYMREF) &&
                    !strcmp(head_ref, lock->ref_name)) {
                        struct strbuf log_err = STRBUF_INIT;
                if (head_ref && (head_flag & REF_ISSYMREF) &&
                    !strcmp(head_ref, lock->ref_name)) {
                        struct strbuf log_err = STRBUF_INIT;

-                       if (files_log_ref_write("HEAD", lock->old_oid.hash, sha1,
-                                         logmsg, 0, &log_err)) {
+                       if (files_log_ref_write(refs, "HEAD",
+                                               lock->old_oid.hash, sha1,
+                                               logmsg, 0, &log_err)) {

                                error("%s", log_err.buf);
                                strbuf_release(&log_err);
                        }
                                error("%s", log_err.buf);
                                strbuf_release(&log_err);
                        }


@@ -3039,24 +3062,26 @@ static int create_ref_symlink(struct ref_lock *lock, const char *target)
        return ret;
 }
 
        return ret;
 }
 

-static void update_symref_reflog(struct ref_lock *lock, const char *refname,
+static void update_symref_reflog(struct files_ref_store *refs,
+                                struct ref_lock *lock, const char *refname,

                                 const char *target, const char *logmsg)
 {
        struct strbuf err = STRBUF_INIT;
        unsigned char new_sha1[20];
        if (logmsg && !read_ref(target, new_sha1) &&
                                 const char *target, const char *logmsg)
 {
        struct strbuf err = STRBUF_INIT;
        unsigned char new_sha1[20];
        if (logmsg && !read_ref(target, new_sha1) &&

-           files_log_ref_write(refname, lock->old_oid.hash, new_sha1,
-                               logmsg, 0, &err)) {
+           files_log_ref_write(refs, refname, lock->old_oid.hash,
+                               new_sha1, logmsg, 0, &err)) {

                error("%s", err.buf);
                strbuf_release(&err);
        }
 }
 
                error("%s", err.buf);
                strbuf_release(&err);
        }
 }
 

-static int create_symref_locked(struct ref_lock *lock, const char *refname,
+static int create_symref_locked(struct files_ref_store *refs,
+                               struct ref_lock *lock, const char *refname,

                                const char *target, const char *logmsg)
 {
        if (prefer_symlink_refs && !create_ref_symlink(lock, target)) {
                                const char *target, const char *logmsg)
 {
        if (prefer_symlink_refs && !create_ref_symlink(lock, target)) {

-               update_symref_reflog(lock, refname, target, logmsg);
+               update_symref_reflog(refs, lock, refname, target, logmsg);

                return 0;
        }
 
                return 0;
        }
 


@@ -3064,7 +3089,7 @@ static int create_symref_locked(struct ref_lock *lock, const char *refname,
                return error("unable to fdopen %s: %s",
                             lock->lk->tempfile.filename.buf, strerror(errno));
 
                return error("unable to fdopen %s: %s",
                             lock->lk->tempfile.filename.buf, strerror(errno));
 

-       update_symref_reflog(lock, refname, target, logmsg);
+       update_symref_reflog(refs, lock, refname, target, logmsg);

 
        /* no error check; commit_ref will check ferror */
        fprintf(lock->lk->tempfile.fp, "ref: %s\n", target);
 
        /* no error check; commit_ref will check ferror */
        fprintf(lock->lk->tempfile.fp, "ref: %s\n", target);


@@ -3093,13 +3118,20 @@ static int files_create_symref(struct ref_store *ref_store,
                return -1;
        }
 
                return -1;
        }
 

-       ret = create_symref_locked(lock, refname, target, logmsg);
+       ret = create_symref_locked(refs, lock, refname, target, logmsg);

        unlock_ref(lock);
        return ret;
 }
 
 int set_worktree_head_symref(const char *gitdir, const char *target, const char *logmsg)
 {
        unlock_ref(lock);
        return ret;
 }
 
 int set_worktree_head_symref(const char *gitdir, const char *target, const char *logmsg)
 {

+       /*
+        * FIXME: this obviously will not work well for future refs
+        * backends. This function needs to die.
+        */
+       struct files_ref_store *refs =
+               files_downcast(get_ref_store(NULL), 0, "set_head_symref");
+

        static struct lock_file head_lock;
        struct ref_lock *lock;
        struct strbuf head_path = STRBUF_INIT;
        static struct lock_file head_lock;
        struct ref_lock *lock;
        struct strbuf head_path = STRBUF_INIT;


@@ -3126,7 +3158,7 @@ int set_worktree_head_symref(const char *gitdir, const char *target, const char
        lock->lk = &head_lock;
        lock->ref_name = xstrdup(head_rel);
 
        lock->lk = &head_lock;
        lock->ref_name = xstrdup(head_rel);
 

-       ret = create_symref_locked(lock, head_rel, target, logmsg);
+       ret = create_symref_locked(refs, lock, head_rel, target, logmsg);

 
        unlock_ref(lock); /* will free lock */
        strbuf_release(&head_path);
 
        unlock_ref(lock); /* will free lock */
        strbuf_release(&head_path);


@@ -3136,14 +3168,13 @@ int set_worktree_head_symref(const char *gitdir, const char *target, const char
 static int files_reflog_exists(struct ref_store *ref_store,
                               const char *refname)
 {
 static int files_reflog_exists(struct ref_store *ref_store,
                               const char *refname)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "reflog_exists");

        struct strbuf sb = STRBUF_INIT;
        struct stat st;
        int ret;
 
        struct strbuf sb = STRBUF_INIT;
        struct stat st;
        int ret;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "reflog_exists");
-
-       strbuf_git_path(&sb, "logs/%s", refname);
+       files_reflog_path(refs, &sb, refname);

        ret = !lstat(sb.buf, &st) && S_ISREG(st.st_mode);
        strbuf_release(&sb);
        return ret;
        ret = !lstat(sb.buf, &st) && S_ISREG(st.st_mode);
        strbuf_release(&sb);
        return ret;


@@ -3152,13 +3183,12 @@ static int files_reflog_exists(struct ref_store *ref_store,
 static int files_delete_reflog(struct ref_store *ref_store,
                               const char *refname)
 {
 static int files_delete_reflog(struct ref_store *ref_store,
                               const char *refname)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "delete_reflog");

        struct strbuf sb = STRBUF_INIT;
        int ret;
 
        struct strbuf sb = STRBUF_INIT;
        int ret;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "delete_reflog");
-
-       strbuf_git_path(&sb, "logs/%s", refname);
+       files_reflog_path(refs, &sb, refname);

        ret = remove_path(sb.buf);
        strbuf_release(&sb);
        return ret;
        ret = remove_path(sb.buf);
        strbuf_release(&sb);
        return ret;


@@ -3209,15 +3239,14 @@ static int files_for_each_reflog_ent_reverse(struct ref_store *ref_store,
                                             each_reflog_ent_fn fn,
                                             void *cb_data)
 {
                                             each_reflog_ent_fn fn,
                                             void *cb_data)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "for_each_reflog_ent_reverse");

        struct strbuf sb = STRBUF_INIT;
        FILE *logfp;
        long pos;
        int ret = 0, at_tail = 1;
 
        struct strbuf sb = STRBUF_INIT;
        FILE *logfp;
        long pos;
        int ret = 0, at_tail = 1;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "for_each_reflog_ent_reverse");
-
-       strbuf_git_path(&sb, "logs/%s", refname);
+       files_reflog_path(refs, &sb, refname);

        logfp = fopen(sb.buf, "r");
        strbuf_release(&sb);
        if (!logfp)
        logfp = fopen(sb.buf, "r");
        strbuf_release(&sb);
        if (!logfp)


@@ -3318,14 +3347,13 @@ static int files_for_each_reflog_ent(struct ref_store *ref_store,
                                     const char *refname,
                                     each_reflog_ent_fn fn, void *cb_data)
 {
                                     const char *refname,
                                     each_reflog_ent_fn fn, void *cb_data)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "for_each_reflog_ent");

        FILE *logfp;
        struct strbuf sb = STRBUF_INIT;
        int ret = 0;
 
        FILE *logfp;
        struct strbuf sb = STRBUF_INIT;
        int ret = 0;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "for_each_reflog_ent");
-
-       strbuf_git_path(&sb, "logs/%s", refname);
+       files_reflog_path(refs, &sb, refname);

        logfp = fopen(sb.buf, "r");
        strbuf_release(&sb);
        if (!logfp)
        logfp = fopen(sb.buf, "r");
        strbuf_release(&sb);
        if (!logfp)


@@ -3407,15 +3435,14 @@ static struct ref_iterator_vtable files_reflog_iterator_vtable = {
 
 static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store)
 {
 
 static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store)
 {

+       struct files_ref_store *refs =
+               files_downcast(ref_store, 0, "reflog_iterator_begin");

        struct files_reflog_iterator *iter = xcalloc(1, sizeof(*iter));
        struct ref_iterator *ref_iterator = &iter->base;
        struct strbuf sb = STRBUF_INIT;
 
        struct files_reflog_iterator *iter = xcalloc(1, sizeof(*iter));
        struct ref_iterator *ref_iterator = &iter->base;
        struct strbuf sb = STRBUF_INIT;
 

-       /* Check validity (but we don't need the result): */
-       files_downcast(ref_store, 0, "reflog_iterator_begin");
-

        base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable);
        base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable);

-       strbuf_git_path(&sb, "logs");
+       files_reflog_path(refs, &sb, NULL);

        iter->dir_iterator = dir_iterator_begin(sb.buf);
        strbuf_release(&sb);
        return ref_iterator;
        iter->dir_iterator = dir_iterator_begin(sb.buf);
        strbuf_release(&sb);
        return ref_iterator;


@@ -3840,7 +3867,8 @@ static int files_transaction_commit(struct ref_store *ref_store,
 
                if (update->flags & REF_NEEDS_COMMIT ||
                    update->flags & REF_LOG_ONLY) {
 
                if (update->flags & REF_NEEDS_COMMIT ||
                    update->flags & REF_LOG_ONLY) {

-                       if (files_log_ref_write(lock->ref_name,
+                       if (files_log_ref_write(refs,
+                                               lock->ref_name,

                                                lock->old_oid.hash,
                                                update->new_sha1,
                                                update->msg, update->flags,
                                                lock->old_oid.hash,
                                                update->new_sha1,
                                                update->msg, update->flags,


@@ -3900,9 +3928,9 @@ static int files_transaction_commit(struct ref_store *ref_store,
        /* Delete the reflogs of any references that were deleted: */
        for_each_string_list_item(ref_to_delete, &refs_to_delete) {
                strbuf_reset(&sb);
        /* Delete the reflogs of any references that were deleted: */
        for_each_string_list_item(ref_to_delete, &refs_to_delete) {
                strbuf_reset(&sb);

-               strbuf_git_path(&sb, "logs/%s", ref_to_delete->string);
+               files_reflog_path(refs, &sb, ref_to_delete->string);

                if (!unlink_or_warn(sb.buf))
                if (!unlink_or_warn(sb.buf))

-                       try_remove_empty_parents(ref_to_delete->string,
+                       try_remove_empty_parents(refs, ref_to_delete->string,

                                                 REMOVE_EMPTY_PARENTS_REFLOG);
        }
 
                                                 REMOVE_EMPTY_PARENTS_REFLOG);
        }
 


@@ -3926,7 +3954,7 @@ static int files_transaction_commit(struct ref_store *ref_store,
                         * can only work because we have already
                         * removed the lockfile.)
                         */
                         * can only work because we have already
                         * removed the lockfile.)
                         */

-                       try_remove_empty_parents(update->refname,
+                       try_remove_empty_parents(refs, update->refname,

                                                 REMOVE_EMPTY_PARENTS_REF);
                }
        }
                                                 REMOVE_EMPTY_PARENTS_REF);
                }
        }


@@ -4077,6 +4105,7 @@ static int files_reflog_expire(struct ref_store *ref_store,
        static struct lock_file reflog_lock;
        struct expire_reflog_cb cb;
        struct ref_lock *lock;
        static struct lock_file reflog_lock;
        struct expire_reflog_cb cb;
        struct ref_lock *lock;

+       struct strbuf log_file_sb = STRBUF_INIT;

        char *log_file;
        int status = 0;
        int type;
        char *log_file;
        int status = 0;
        int type;


@@ -4105,7 +4134,8 @@ static int files_reflog_expire(struct ref_store *ref_store,
                return 0;
        }
 
                return 0;
        }
 

-       log_file = git_pathdup("logs/%s", refname);
+       files_reflog_path(refs, &log_file_sb, refname);
+       log_file = strbuf_detach(&log_file_sb, NULL);

        if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {
                /*
                 * Even though holding $GIT_DIR/logs/$reflog.lock has
        if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {
                /*
                 * Even though holding $GIT_DIR/logs/$reflog.lock has