1 #include "../perf.h" 2 #include <stdlib.h> 3 #include <stdio.h> 4 #include <string.h> 5 #include "session.h" 6 #include "thread.h" 7 #include "thread-stack.h" 8 #include "util.h" 9 #include "debug.h" 10 #include "comm.h" 11 #include "unwind.h" 12 13 int thread__init_map_groups(struct thread *thread, struct machine *machine) 14 { 15 struct thread *leader; 16 pid_t pid = thread->pid_; 17 18 if (pid == thread->tid || pid == -1) { 19 thread->mg = map_groups__new(machine); 20 } else { 21 leader = __machine__findnew_thread(machine, pid, pid); 22 if (leader) 23 thread->mg = map_groups__get(leader->mg); 24 } 25 26 return thread->mg ? 0 : -1; 27 } 28 29 struct thread *thread__new(pid_t pid, pid_t tid) 30 { 31 char *comm_str; 32 struct comm *comm; 33 struct thread *thread = zalloc(sizeof(*thread)); 34 35 if (thread != NULL) { 36 thread->pid_ = pid; 37 thread->tid = tid; 38 thread->ppid = -1; 39 thread->cpu = -1; 40 INIT_LIST_HEAD(&thread->comm_list); 41 42 if (unwind__prepare_access(thread) < 0) 43 goto err_thread; 44 45 comm_str = malloc(32); 46 if (!comm_str) 47 goto err_thread; 48 49 snprintf(comm_str, 32, ":%d", tid); 50 comm = comm__new(comm_str, 0, false); 51 free(comm_str); 52 if (!comm) 53 goto err_thread; 54 55 list_add(&comm->list, &thread->comm_list); 56 atomic_set(&thread->refcnt, 0); 57 RB_CLEAR_NODE(&thread->rb_node); 58 } 59 60 return thread; 61 62 err_thread: 63 free(thread); 64 return NULL; 65 } 66 67 void thread__delete(struct thread *thread) 68 { 69 struct comm *comm, *tmp; 70 71 BUG_ON(!RB_EMPTY_NODE(&thread->rb_node)); 72 73 thread_stack__free(thread); 74 75 if (thread->mg) { 76 map_groups__put(thread->mg); 77 thread->mg = NULL; 78 } 79 list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) { 80 list_del(&comm->list); 81 comm__free(comm); 82 } 83 unwind__finish_access(thread); 84 85 free(thread); 86 } 87 88 struct thread *thread__get(struct thread *thread) 89 { 90 if (thread) 91 atomic_inc(&thread->refcnt); 92 return thread; 93 } 94 95 void thread__put(struct thread *thread) 96 { 97 if (thread && atomic_dec_and_test(&thread->refcnt)) { 98 list_del_init(&thread->node); 99 thread__delete(thread); 100 } 101 } 102 103 struct comm *thread__comm(const struct thread *thread) 104 { 105 if (list_empty(&thread->comm_list)) 106 return NULL; 107 108 return list_first_entry(&thread->comm_list, struct comm, list); 109 } 110 111 struct comm *thread__exec_comm(const struct thread *thread) 112 { 113 struct comm *comm, *last = NULL; 114 115 list_for_each_entry(comm, &thread->comm_list, list) { 116 if (comm->exec) 117 return comm; 118 last = comm; 119 } 120 121 return last; 122 } 123 124 int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp, 125 bool exec) 126 { 127 struct comm *new, *curr = thread__comm(thread); 128 int err; 129 130 /* Override the default :tid entry */ 131 if (!thread->comm_set) { 132 err = comm__override(curr, str, timestamp, exec); 133 if (err) 134 return err; 135 } else { 136 new = comm__new(str, timestamp, exec); 137 if (!new) 138 return -ENOMEM; 139 list_add(&new->list, &thread->comm_list); 140 141 if (exec) 142 unwind__flush_access(thread); 143 } 144 145 thread->comm_set = true; 146 147 return 0; 148 } 149 150 const char *thread__comm_str(const struct thread *thread) 151 { 152 const struct comm *comm = thread__comm(thread); 153 154 if (!comm) 155 return NULL; 156 157 return comm__str(comm); 158 } 159 160 /* CHECKME: it should probably better return the max comm len from its comm list */ 161 int thread__comm_len(struct thread *thread) 162 { 163 if (!thread->comm_len) { 164 const char *comm = thread__comm_str(thread); 165 if (!comm) 166 return 0; 167 thread->comm_len = strlen(comm); 168 } 169 170 return thread->comm_len; 171 } 172 173 size_t thread__fprintf(struct thread *thread, FILE *fp) 174 { 175 return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) + 176 map_groups__fprintf(thread->mg, fp); 177 } 178 179 void thread__insert_map(struct thread *thread, struct map *map) 180 { 181 map_groups__fixup_overlappings(thread->mg, map, stderr); 182 map_groups__insert(thread->mg, map); 183 } 184 185 static int thread__clone_map_groups(struct thread *thread, 186 struct thread *parent) 187 { 188 int i; 189 190 /* This is new thread, we share map groups for process. */ 191 if (thread->pid_ == parent->pid_) 192 return 0; 193 194 if (thread->mg == parent->mg) { 195 pr_debug("broken map groups on thread %d/%d parent %d/%d\n", 196 thread->pid_, thread->tid, parent->pid_, parent->tid); 197 return 0; 198 } 199 200 /* But this one is new process, copy maps. */ 201 for (i = 0; i < MAP__NR_TYPES; ++i) 202 if (map_groups__clone(thread->mg, parent->mg, i) < 0) 203 return -ENOMEM; 204 205 return 0; 206 } 207 208 int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp) 209 { 210 int err; 211 212 if (parent->comm_set) { 213 const char *comm = thread__comm_str(parent); 214 if (!comm) 215 return -ENOMEM; 216 err = thread__set_comm(thread, comm, timestamp); 217 if (err) 218 return err; 219 } 220 221 thread->ppid = parent->tid; 222 return thread__clone_map_groups(thread, parent); 223 } 224 225 void thread__find_cpumode_addr_location(struct thread *thread, 226 enum map_type type, u64 addr, 227 struct addr_location *al) 228 { 229 size_t i; 230 const u8 const cpumodes[] = { 231 PERF_RECORD_MISC_USER, 232 PERF_RECORD_MISC_KERNEL, 233 PERF_RECORD_MISC_GUEST_USER, 234 PERF_RECORD_MISC_GUEST_KERNEL 235 }; 236 237 for (i = 0; i < ARRAY_SIZE(cpumodes); i++) { 238 thread__find_addr_location(thread, cpumodes[i], type, addr, al); 239 if (al->map) 240 break; 241 } 242 } 243