if (err)
                goto out;
 
-       strlist__for_each(pos, list) {
+       strlist__for_each_entry(pos, list) {
                err = build_id_cache__remove_s(pos->s);
                pr_debug("Removing %s %s: %s\n", pos->s, pathname,
                         err ? "FAIL" : "Ok");
        if (add_name_list_str) {
                list = strlist__new(add_name_list_str, NULL);
                if (list) {
-                       strlist__for_each(pos, list)
+                       strlist__for_each_entry(pos, list)
                                if (build_id_cache__add_file(pos->s)) {
                                        if (errno == EEXIST) {
                                                pr_debug("%s already in the cache\n",
        if (remove_name_list_str) {
                list = strlist__new(remove_name_list_str, NULL);
                if (list) {
-                       strlist__for_each(pos, list)
+                       strlist__for_each_entry(pos, list)
                                if (build_id_cache__remove_file(pos->s)) {
                                        if (errno == ENOENT) {
                                                pr_debug("%s wasn't in the cache\n",
        if (purge_name_list_str) {
                list = strlist__new(purge_name_list_str, NULL);
                if (list) {
-                       strlist__for_each(pos, list)
+                       strlist__for_each_entry(pos, list)
                                if (build_id_cache__purge_path(pos->s)) {
                                        if (errno == ENOENT) {
                                                pr_debug("%s wasn't in the cache\n",
        if (update_name_list_str) {
                list = strlist__new(update_name_list_str, NULL);
                if (list) {
-                       strlist__for_each(pos, list)
+                       strlist__for_each_entry(pos, list)
                                if (build_id_cache__update_file(pos->s)) {
                                        if (errno == ENOENT) {
                                                pr_debug("%s wasn't in the cache\n",
 
 
        ret = probe_file__get_events(kfd, filter, klist);
        if (ret == 0) {
-               strlist__for_each(ent, klist)
+               strlist__for_each_entry(ent, klist)
                        pr_info("Removed event: %s\n", ent->s);
 
                ret = probe_file__del_strlist(kfd, klist);
 
        ret2 = probe_file__get_events(ufd, filter, ulist);
        if (ret2 == 0) {
-               strlist__for_each(ent, ulist)
+               strlist__for_each_entry(ent, ulist)
                        pr_info("Removed event: %s\n", ent->s);
 
                ret2 = probe_file__del_strlist(ufd, ulist);
 
 
        i = 0;
 
-       strlist__for_each(pos, trace->ev_qualifier) {
+       strlist__for_each_entry(pos, trace->ev_qualifier) {
                const char *sc = pos->s;
                int id = syscalltbl__id(trace->sctbl, sc);
 
 
                zfree(&vl->point.symbol);
                nvars = 0;
                if (vl->vars) {
-                       strlist__for_each(node, vl->vars) {
+                       strlist__for_each_entry(node, vl->vars) {
                                var = strchr(node->s, '\t') + 1;
                                if (strfilter__compare(_filter, var)) {
                                        fprintf(stdout, "\t\t%s\n", node->s);
        if (!rawlist)
                return -ENOMEM;
 
-       strlist__for_each(ent, rawlist) {
+       strlist__for_each_entry(ent, rawlist) {
                ret = parse_probe_trace_command(ent->s, &tev);
                if (ret >= 0) {
                        if (!filter_probe_trace_event(&tev, filter))
 
        if (!rawlist)
                return NULL;
        sl = strlist__new(NULL, NULL);
-       strlist__for_each(ent, rawlist) {
+       strlist__for_each_entry(ent, rawlist) {
                ret = parse_probe_trace_command(ent->s, &tev);
                if (ret < 0)
                        break;
        if (!namelist)
                return -ENOENT;
 
-       strlist__for_each(ent, namelist) {
+       strlist__for_each_entry(ent, namelist) {
                p = strchr(ent->s, ':');
                if ((p && strfilter__compare(filter, p + 1)) ||
                    strfilter__compare(filter, ent->s)) {
        int ret = 0;
        struct str_node *ent;
 
-       strlist__for_each(ent, namelist) {
+       strlist__for_each_entry(ent, namelist) {
                ret = __del_trace_probe_event(fd, ent);
                if (ret < 0)
                        break;
        if (ret < (int)iov[1].iov_len + 2)
                goto rollback;
 
-       strlist__for_each(snode, entry->tevlist) {
+       strlist__for_each_entry(snode, entry->tevlist) {
                iov[0].iov_base = (void *)snode->s;
                iov[0].iov_len = strlen(snode->s);
                iov[1].iov_base = (void *)"\n"; iov[1].iov_len = 1;
 
  * @pos:       the &struct str_node to use as a loop cursor.
  * @slist:     the &struct strlist for loop.
  */
-#define strlist__for_each(pos, slist)  \
+#define strlist__for_each_entry(pos, slist)    \
        for (pos = strlist__first(slist); pos; pos = strlist__next(pos))
 
 /**
  * @n:         another &struct str_node to use as temporary storage.
  * @slist:     the &struct strlist for loop.
  */
-#define strlist__for_each_safe(pos, n, slist)  \
+#define strlist__for_each_entry_safe(pos, n, slist)    \
        for (pos = strlist__first(slist), n = strlist__next(pos); pos;\
             pos = n, n = strlist__next(n))
 #endif /* __PERF_STRLIST_H */
 
        if (!dirs)
                return -1;
 
-       strlist__for_each(nd, dirs) {
+       strlist__for_each_entry(nd, dirs) {
                scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
                          "%s/%s/kallsyms", dir, nd->s);
                if (!validate_kcore_addresses(kallsyms_filename, map)) {
 
        if (!slist)
                return NULL;
 
-       strlist__for_each(pos, slist) {
+       strlist__for_each_entry(pos, slist) {
                pid = strtol(pos->s, &end_ptr, 10);
 
                if (pid == INT_MIN || pid == INT_MAX ||
        if (!slist)
                return NULL;
 
-       strlist__for_each(pos, slist) {
+       strlist__for_each_entry(pos, slist) {
                tid = strtol(pos->s, &end_ptr, 10);
 
                if (tid == INT_MIN || tid == INT_MAX ||