1 files changed, 0 insertions, 202 deletions

diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index fd1f2faaade4..b276c187802a 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -54,21 +54,6 @@ static char *cleanup_path(char *path)
         return path;
 }
 
-char *mksnpath(char *buf, size_t n, const char *fmt, ...)
-{
-        va_list args;
-        unsigned len;
-
-        va_start(args, fmt);
-        len = vsnprintf(buf, n, fmt, args);
-        va_end(args);
-        if (len >= n) {
-                strlcpy(buf, bad_path, n);
-                return buf;
-        }
-        return cleanup_path(buf);
-}
-
 static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
 {
         const char *perf_dir = get_perf_dir();
@@ -89,15 +74,6 @@ bad:
         return buf;
 }
 
-char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
-{
-        va_list args;
-        va_start(args, fmt);
-        (void)perf_vsnpath(buf, n, fmt, args);
-        va_end(args);
-        return buf;
-}
-
 char *perf_pathdup(const char *fmt, ...)
 {
         char path[PATH_MAX];
@@ -143,184 +119,6 @@ char *perf_path(const char *fmt, ...)
         return cleanup_path(pathname);
 }
 
-
-/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
-int perf_mkstemp(char *path, size_t len, const char *template)
-{
-        const char *tmp;
-        size_t n;
-
-        tmp = getenv("TMPDIR");
-        if (!tmp)
-                tmp = "/tmp";
-        n = snprintf(path, len, "%s/%s", tmp, template);
-        if (len <= n) {
-                errno = ENAMETOOLONG;
-                return -1;
-        }
-        return mkstemp(path);
-}
-
-
-const char *make_relative_path(const char *abs_path, const char *base)
-{
-        static char buf[PATH_MAX + 1];
-        int baselen;
-
-        if (!base)
-                return abs_path;
-
-        baselen = strlen(base);
-        if (prefixcmp(abs_path, base))
-                return abs_path;
-        if (abs_path[baselen] == '/')
-                baselen++;
-        else if (base[baselen - 1] != '/')
-                return abs_path;
-
-        strcpy(buf, abs_path + baselen);
-
-        return buf;
-}
-
-/*
- * It is okay if dst == src, but they should not overlap otherwise.
- *
- * Performs the following normalizations on src, storing the result in dst:
- * - Ensures that components are separated by '/' (Windows only)
- * - Squashes sequences of '/'.
- * - Removes "." components.
- * - Removes ".." components, and the components the precede them.
- * Returns failure (non-zero) if a ".." component appears as first path
- * component anytime during the normalization. Otherwise, returns success (0).
- *
- * Note that this function is purely textual.  It does not follow symlinks,
- * verify the existence of the path, or make any system calls.
- */
-int normalize_path_copy(char *dst, const char *src)
-{
-        char *dst0;
-
-        if (has_dos_drive_prefix(src)) {
-                *dst++ = *src++;
-                *dst++ = *src++;
-        }
-        dst0 = dst;
-
-        if (is_dir_sep(*src)) {
-                *dst++ = '/';
-                while (is_dir_sep(*src))
-                        src++;
-        }
-
-        for (;;) {
-                char c = *src;
-
-                /*
-                 * A path component that begins with . could be
-                 * special:
-                 * (1) "." and ends   -- ignore and terminate.
-                 * (2) "./"           -- ignore them, eat slash and continue.
-                 * (3) ".." and ends  -- strip one and terminate.
-                 * (4) "../"          -- strip one, eat slash and continue.
-                 */
-                if (c == '.') {
-                        if (!src[1]) {
-                                /* (1) */
-                                src++;
-                        } else if (is_dir_sep(src[1])) {
-                                /* (2) */
-                                src += 2;
-                                while (is_dir_sep(*src))
-                                        src++;
-                                continue;
-                        } else if (src[1] == '.') {
-                                if (!src[2]) {
-                                        /* (3) */
-                                        src += 2;
-                                        goto up_one;
-                                } else if (is_dir_sep(src[2])) {
-                                        /* (4) */
-                                        src += 3;
-                                        while (is_dir_sep(*src))
-                                                src++;
-                                        goto up_one;
-                                }
-                        }
-                }
-
-                /* copy up to the next '/', and eat all '/' */
-                while ((c = *src++) != '\0' && !is_dir_sep(c))
-                        *dst++ = c;
-                if (is_dir_sep(c)) {
-                        *dst++ = '/';
-                        while (is_dir_sep(c))
-                                c = *src++;
-                        src--;
-                } else if (!c)
-                        break;
-                continue;
-
-        up_one:
-                /*
-                 * dst0..dst is prefix portion, and dst[-1] is '/';
-                 * go up one level.
-                 */
-                dst--;  /* go to trailing '/' */
-                if (dst <= dst0)
-                        return -1;
-                /* Windows: dst[-1] cannot be backslash anymore */
-                while (dst0 < dst && dst[-1] != '/')
-                        dst--;
-        }
-        *dst = '\0';
-        return 0;
-}
-
-/*
- * path = Canonical absolute path
- * prefix_list = Colon-separated list of absolute paths
- *
- * Determines, for each path in prefix_list, whether the "prefix" really
- * is an ancestor directory of path.  Returns the length of the longest
- * ancestor directory, excluding any trailing slashes, or -1 if no prefix
- * is an ancestor.  (Note that this means 0 is returned if prefix_list is
- * "/".) "/foo" is not considered an ancestor of "/foobar".  Directories
- * are not considered to be their own ancestors.  path must be in a
- * canonical form: empty components, or "." or ".." components are not
- * allowed.  prefix_list may be null, which is like "".
- */
-int longest_ancestor_length(const char *path, const char *prefix_list)
-{
-        char buf[PATH_MAX+1];
-        const char *ceil, *colon;
-        int len, max_len = -1;
-
-        if (prefix_list == NULL || !strcmp(path, "/"))
-                return -1;
-
-        for (colon = ceil = prefix_list; *colon; ceil = colon+1) {
-                for (colon = ceil; *colon && *colon != PATH_SEP; colon++);
-                len = colon - ceil;
-                if (len == 0 || len > PATH_MAX || !is_absolute_path(ceil))
-                        continue;
-                strlcpy(buf, ceil, len+1);
-                if (normalize_path_copy(buf, buf) < 0)
-                        continue;
-                len = strlen(buf);
-                if (len > 0 && buf[len-1] == '/')
-                        buf[--len] = '\0';
-
-                if (!strncmp(path, buf, len) &&
-                    path[len] == '/' &&
-                    len > max_len) {
-                        max_len = len;
-                }
-        }
-
-        return max_len;
-}
-
 /* strip arbitrary amount of directory separators at end of path */
 static inline int chomp_trailing_dir_sep(const char *path, int len)
 {