#include <linux/string.h>
 #include <linux/err.h>
 
-static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid)
+static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid, size_t sbuildid_size)
 {
        char root_dir[PATH_MAX];
        char *p;
        if (!p)
                return -1;
        *p = '\0';
-       return sysfs__sprintf_build_id(root_dir, sbuildid);
+       return sysfs__snprintf_build_id(root_dir, sbuildid, sbuildid_size);
 }
 
 static int build_id_cache__kcore_dir(char *dir, size_t sz)
                return -1;
        *p = '\0';
 
-       if (build_id_cache__kcore_buildid(from_dir, sbuildid) < 0)
+       if (build_id_cache__kcore_buildid(from_dir, sbuildid, sizeof(sbuildid)) < 0)
                return -1;
 
        scnprintf(to_dir, sizeof(to_dir), "%s/%s/%s",
                return -1;
        }
 
-       build_id__sprintf(&bid, sbuild_id);
+       build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
        err = build_id_cache__add_s(sbuild_id, filename, nsi,
                                    false, false);
        pr_debug("Adding %s %s: %s\n", sbuild_id, filename,
                return -1;
        }
 
-       build_id__sprintf(&bid, sbuild_id);
+       build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
        err = build_id_cache__remove_s(sbuild_id);
        pr_debug("Removing %s %s: %s\n", sbuild_id, filename,
                 err ? "FAIL" : "Ok");
        }
        err = 0;
 
-       build_id__sprintf(&bid, sbuild_id);
+       build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
        if (build_id_cache__cached(sbuild_id))
                err = build_id_cache__remove_s(sbuild_id);
 
 
 
        memset(bid_buf, 0, sizeof(bid_buf));
        if (dso__has_build_id(dso))
-               build_id__sprintf(dso__bid_const(dso), bid_buf);
+               build_id__snprintf(dso__bid_const(dso), bid_buf, sizeof(bid_buf));
        printf("%s %16" PRIx64 " %16" PRIx64, bid_buf, map__start(map), map__end(map));
        if (dso_long_name != NULL)
                printf(" %s", dso_long_name);
        char sbuild_id[SBUILD_ID_SIZE];
        int ret;
 
-       ret = sysfs__sprintf_build_id("/", sbuild_id);
+       ret = sysfs__snprintf_build_id("/", sbuild_id, sizeof(sbuild_id));
        if (ret != sizeof(sbuild_id))
                return ret < 0 ? ret : -EINVAL;
 
        char sbuild_id[SBUILD_ID_SIZE];
        int ret;
 
-       ret = filename__sprintf_build_id(name, sbuild_id);
+       ret = filename__snprintf_build_id(name, sbuild_id, sizeof(sbuild_id));
        if (ret != sizeof(sbuild_id))
                return ret < 0 ? ret : -EINVAL;
 
 
                return err;
        }
 
-       build_id__sprintf(&bid, sbuild_id);
+       build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
        err = build_id_cache__add_s(sbuild_id, filename, NULL, false, false);
        if (err < 0)
                pr_debug("Failed to add build id cache of %s\n", filename);
 
        return 0;
 }
 
-int build_id__sprintf(const struct build_id *build_id, char *bf)
+int build_id__snprintf(const struct build_id *build_id, char *bf, size_t bf_size)
 {
-       char *bid = bf;
-       const u8 *raw = build_id->data;
-       size_t i;
-
-       bf[0] = 0x0;
+       size_t offs = 0;
 
-       for (i = 0; i < build_id->size; ++i) {
-               sprintf(bid, "%02x", *raw);
-               ++raw;
-               bid += 2;
-       }
+       for (size_t i = 0; i < build_id->size && offs < bf_size; ++i)
+               offs += snprintf(bf + offs, bf_size - offs, "%02x", build_id->data[i]);
 
-       return (bid - bf) + 1;
+       return offs;
 }
 
-int sysfs__sprintf_build_id(const char *root_dir, char *sbuild_id)
+int sysfs__snprintf_build_id(const char *root_dir, char *sbuild_id, size_t sbuild_id_size)
 {
        char notes[PATH_MAX];
        struct build_id bid;
        if (ret < 0)
                return ret;
 
-       return build_id__sprintf(&bid, sbuild_id);
+       return build_id__snprintf(&bid, sbuild_id, sbuild_id_size);
 }
 
-int filename__sprintf_build_id(const char *pathname, char *sbuild_id)
+int filename__snprintf_build_id(const char *pathname, char *sbuild_id, size_t sbuild_id_size)
 {
        struct build_id bid;
        int ret;
        if (ret < 0)
                return ret;
 
-       return build_id__sprintf(&bid, sbuild_id);
+       return build_id__snprintf(&bid, sbuild_id, sbuild_id_size);
 }
 
 /* asnprintf consolidates asprintf and snprintf */
                return false;
 
        if (!strcmp(pathname, DSO__NAME_KALLSYMS))
-               ret = sysfs__sprintf_build_id("/", real_sbuild_id);
+               ret = sysfs__snprintf_build_id("/", real_sbuild_id, sizeof(real_sbuild_id));
        else if (pathname[0] == '/')
-               ret = filename__sprintf_build_id(pathname, real_sbuild_id);
+               ret = filename__snprintf_build_id(pathname, real_sbuild_id, sizeof(real_sbuild_id));
        else
                ret = -EINVAL;  /* Should we support other special DSO cache? */
        if (ret >= 0)
        if (!dso__has_build_id(dso))
                return NULL;
 
-       build_id__sprintf(dso__bid_const(dso), sbuild_id);
+       build_id__snprintf(dso__bid_const(dso), sbuild_id, sizeof(sbuild_id));
        linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
        if (!linkname)
                return NULL;
 {
        char sbuild_id[SBUILD_ID_SIZE];
 
-       build_id__sprintf(bid, sbuild_id);
+       build_id__snprintf(bid, sbuild_id, sizeof(sbuild_id));
 
        return __build_id_cache__add_s(sbuild_id, name, nsi, is_kallsyms,
                                       is_vdso, proper_name, root_dir);
 
 struct nsinfo;
 
 void build_id__init(struct build_id *bid, const u8 *data, size_t size);
-int build_id__sprintf(const struct build_id *build_id, char *bf);
+int build_id__snprintf(const struct build_id *build_id, char *bf, size_t bf_size);
 bool build_id__is_defined(const struct build_id *bid);
-int sysfs__sprintf_build_id(const char *root_dir, char *sbuild_id);
-int filename__sprintf_build_id(const char *pathname, char *sbuild_id);
+int sysfs__snprintf_build_id(const char *root_dir, char *sbuild_id, size_t sbuild_id_size);
+int filename__snprintf_build_id(const char *pathname, char *sbuild_id, size_t sbuild_id_size);
 char *build_id_cache__kallsyms_path(const char *sbuild_id, char *bf,
                                    size_t size);
 
 
                char *build_id_msg = NULL;
 
                if (dso__has_build_id(dso)) {
-                       build_id__sprintf(dso__bid(dso), bf + 15);
+                       build_id__snprintf(dso__bid(dso), bf + 15, sizeof(bf) - 15);
                        build_id_msg = bf;
                }
                scnprintf(buf, buflen,
 
                        break;
                }
 
-               build_id__sprintf(dso__bid_const(dso), build_id_hex);
+               build_id__snprintf(dso__bid_const(dso), build_id_hex, sizeof(build_id_hex));
                len = __symbol__join_symfs(filename, size, "/usr/lib/debug/.build-id/");
                snprintf(filename + len, size - len, "%.2s/%s.debug",
                         build_id_hex, build_id_hex + 2);
 {
        char sbuild_id[SBUILD_ID_SIZE];
 
-       build_id__sprintf(dso__bid(dso), sbuild_id);
+       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
        return fprintf(fp, "%s", sbuild_id);
 }
 
 
 
        if (args->skip && args->skip(dso, args->parm))
                return 0;
-       build_id__sprintf(dso__bid(dso), sbuild_id);
+       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
        args->ret += fprintf(args->fp, "%-40s %s\n", sbuild_id, dso__long_name(dso));
        return 0;
 }
 
 
                build_id__init(&bid, event->mmap2.build_id,
                               event->mmap2.build_id_size);
-               build_id__sprintf(&bid, sbuild_id);
+               build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
 
                return fprintf(fp, " %d/%d: [%#" PRI_lx64 "(%#" PRI_lx64 ") @ %#" PRI_lx64
                                   " <%s>]: %c%c%c%c %s\n",
 
                        free(m.name);
                }
 
-               build_id__sprintf(dso__bid(dso), sbuild_id);
+               build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
                pr_debug("build id event received for %s: %s [%zu]\n",
                         dso__long_name(dso), sbuild_id, size);
                dso__put(dso);
 
                if (dso__has_build_id(dso)) {
                        char sbuild_id[SBUILD_ID_SIZE];
 
-                       build_id__sprintf(dso__bid(dso), sbuild_id);
+                       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
                        pr_debug("%s with build id %s not found", name, sbuild_id);
                } else
                        pr_debug("Failed to open %s", name);
 
        if (!c)
                return NULL;
 
-       build_id__sprintf(dso__bid(dso), sbuild_id);
+       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
        fd = debuginfod_find_debuginfo(c, (const unsigned char *)sbuild_id,
                                        0, &path);
        if (fd >= 0)
        }
        if (dinfo->build_id) {
                build_id__init(&bid, dinfo->build_id, BUILD_ID_SIZE);
-               build_id__sprintf(&bid, sbuild_id);
+               build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
        }
        debuginfo__delete(dinfo);
        if (ret == 0 || ret == -ENOENT) {
 
        if (!target || !strcmp(target, DSO__NAME_KALLSYMS)) {
                target = DSO__NAME_KALLSYMS;
                is_kallsyms = true;
-               ret = sysfs__sprintf_build_id("/", sbuildid);
+               ret = sysfs__snprintf_build_id("/", sbuildid, sizeof(sbuildid));
        } else {
                nsinfo__mountns_enter(nsi, &nsc);
-               ret = filename__sprintf_build_id(target, sbuildid);
+               ret = filename__snprintf_build_id(target, sbuildid, sizeof(sbuildid));
                nsinfo__mountns_exit(&nsc);
        }
 
 
                comp_dir = cu_get_comp_dir(&pf->cu_die);
                if (pf->dbg->build_id) {
                        build_id__init(&bid, pf->dbg->build_id, BUILD_ID_SIZE);
-                       build_id__sprintf(&bid, sbuild_id);
+                       build_id__snprintf(&bid, sbuild_id, sizeof(sbuild_id));
                }
                ret = find_source_path(pf->fname, sbuild_id, comp_dir, &fpath);
                if (ret < 0) {
 
                            const char *sym_field, const char *symoff_field,
                            const char *map_pgoff)
 {
-       char sbuild_id[SBUILD_ID_SIZE];
-
        if (al->map) {
+               char sbuild_id[SBUILD_ID_SIZE];
                struct dso *dso = map__dso(al->map);
 
                pydict_set_item_string_decref(dict, dso_field,
                                              _PyUnicode_FromString(dso__name(dso)));
-               build_id__sprintf(dso__bid(dso), sbuild_id);
+               build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
                pydict_set_item_string_decref(dict, dso_bid_field,
                        _PyUnicode_FromString(sbuild_id));
                pydict_set_item_string_decref(dict, dso_map_start,
        char sbuild_id[SBUILD_ID_SIZE];
        PyObject *t;
 
-       build_id__sprintf(dso__bid(dso), sbuild_id);
+       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
 
        t = tuple_new(5);
 
 
                        goto proc_kallsyms;
        }
 
-       build_id__sprintf(dso__bid(dso), sbuild_id);
+       build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id));
 
        /* Find kallsyms in build-id cache with kcore */
        scnprintf(path, sizeof(path), "%s/%s/%s",