Lines Matching defs:name
196 static void open_library_by_path(const char *name, const char *s, struct loadtask *task, struct zip_info *z_info);
197 static void handle_asan_path_open_by_task(int fd, const char *name, ns_t *namespace, struct loadtask *task, struct zip_info *z_info);
206 int handle_asan_path_open(int fd, const char *name, ns_t *namespace, char *buf, size_t buf_size);
323 strcpy(app_path, app->name);
576 dso->name, verinfo->s, verinfo->v, verinfo->use_vna_hash, verinfo->vna_hash);
588 LD_LOGD("gnu_lookup symbol not found (bloom filter), so:%{public}s s:%{public}s", dso->name, verinfo->s);
610 dso->name, verinfo->s, verinfo->v, verinfo->use_vna_hash, verinfo->vna_hash);
629 "check_sym_accessible dso name [%{public}s] ns_name [%{public}s] not accessible!", dso->name, ns->ns_name);
644 "check_sym_accessible dso name [%{public}s] ns_name [%{public}s] not accessible!", dso->name, ns->ns_name);
1028 const char *name;
1070 name = strings + sym->st_name;
1072 struct verinfo vinfo = { .s = name, .v = ""};
1101 dso->name, name, vinfo.use_vna_hash, vinfo.vna_hash);
1103 dso->name, name);
1120 dso->name, name, def.dso->name);
1183 dso->name, sym ? name : "(local)" );
1212 dso->name, type);
1644 set_bss_vma_name(dso->name, (void *)pgbrk, zeromap_size);
1668 static int path_open(const char *name, const char *s, char *buf, size_t buf_size)
1676 if (snprintf(buf, buf_size, "%.*s/%s", (int)l, s, name) < buf_size) {
1737 origin = p->name;
1743 /* Normally p->name will always be an absolute or relative
1746 * program in the working directory, app.name may not. Fix. */
1778 LD_LOGI("Add DF_1_GLOBAL for %{public}s", p->name);
1849 error("Error allocating function descriptors for %s", p->name);
1890 static struct dso *search_dso_by_name(const char *name, const ns_t *ns) {
1891 LD_LOGD("search_dso_by_name name:%{public}s, ns_name:%{public}s", name, ns ? ns->ns_name: "NULL");
1894 if (p->shortname && !strcmp(p->shortname, name)) {
1895 LD_LOGD("search_dso_by_name found name:%{public}s, ns_name:%{public}s", name, ns ? ns->ns_name: "NULL");
1926 /* Find loaded so by name */
1927 static struct dso *find_library_by_name(const char *name, const ns_t *ns, bool check_inherited)
1929 LD_LOGD("find_library_by_name name:%{public}s, ns_name:%{public}s, check_inherited:%{public}d",
1930 name,
1933 struct dso *p = search_dso_by_name(name, ns);
1938 p = search_dso_by_name(name, inherit->inherited_ns);
1939 if (p && is_sharable(inherit, name)) {
1940 if (app_has_same_name_so(name, ns) != -1) {
1969 const char *name, struct dso *needed_by, ns_t *namespace, bool check_inherited, struct reserved_address_params *reserved_params)
1981 if (!*name) {
1987 if (name[0]=='l' && name[1]=='i' && name[2]=='b') {
1993 if (strncmp(name+3, rp, next-rp) == 0)
2005 name, ldso.name,
2012 if (!strcmp(name, ldso.name)) is_self = 1;
2023 if (strchr(name, '/')) {
2024 pathname = name;
2030 fd = open(name, O_RDONLY|O_CLOEXEC);
2034 /* Search for the name to see if it's already loaded */
2036 p = find_library_by_name(name, namespace, check_inherited);
2041 if (strlen(name) > NAME_MAX) {
2042 LD_LOGE("load_library name exceeding the maximum length, return 0!");
2046 if (namespace->env_paths) fd = path_open(name, namespace->env_paths, buf, sizeof buf);
2053 fd = path_open(name, p->rpath, buf, sizeof buf);
2059 fd = handle_asan_path_open(fd, name, namespace, buf, sizeof buf);
2063 fd = path_open(name, namespace->lib_paths, buf, sizeof buf);
2075 if (strchr(name, '/')==0 && !is_sharable(inherit, name)) continue;
2076 p = load_library(name, needed_by, inherit->inherited_ns, false, reserved_params);
2078 LD_LOGD("load_library search in inherited, found p ,inherited_ns name:%{public}s",
2095 * setup its shortname so it can be found by name. */
2096 if (!p->shortname && pathname != name)
2097 p->shortname = strrchr(p->name, '/')+1;
2143 p->name = p->buf;
2145 strcpy(p->name, pathname);
2146 /* Add a shortname only if name arg was not an explicit pathname. */
2147 if (pathname != name) p->shortname = strrchr(p->name, '/')+1;
2162 (uintptr_t)(p->name+strlen(p->name)+sizeof(size_t)));
2181 if (ldd_mode) dprintf(1, "\t%s => %s (%p)\n", name, pathname, p->base);
2202 error("Error loading dependencies for %s", p->name);
2211 LD_LOGD("loading shared library %{public}s: (needed by %{public}s)", p->strings + p->dynv[i+1], p->name);
2214 p->strings + p->dynv[i+1], p->name);
2265 error("Error recording dependencies for %s", p->name);
2499 p->name);
2673 trace_marker_begin(HITRACE_TAG_MUSL, "calling constructors: ", p->name);
2804 ldso.name = ldso.shortname = "libc.so";
2929 if (interp_off) ldso.name = laddr(&app, interp_off);
2932 app.name = (char *)aux[AT_EXECFN];
2934 app.name = argv[0];
2986 ldso.name = ldname;
2987 app.name = argv[0];
2989 /* Find the name that would have been used for the dynamic
2994 ldso.name = laddr(&app, app.phdr[i].p_vaddr);
2996 dprintf(1, "\t%s (%p)\n", ldso.name, ldso.base);
3043 LD_LOGD("__dls3 ldso.name:%{public}s.", ldso.name);
3045 if (strstr(ldso.name, "-asan")) {
3096 vdso.name = "";
3216 error("Error preparing lazy relocation for %s: %m", p->name);
3234 p->name, p->name, p->nr_dlopen);
3241 p->deps[i]->name, p->name, p->deps[i]->nr_dlopen);
3439 LD_LOGE("dlopen_impl load library header failed for %{public}s", task->name);
3448 LD_LOGE("dlopen_impl load library failed for %{public}s", task->name);
3515 trace_marker_begin(HITRACE_TAG_MUSL, "linking: entry so", p->name);
3584 void dlns_init(Dl_namespace *dlns, const char *name)
3589 if (!name) {
3590 dlns->name[0] = 0;
3595 if (is_permitted(caller_addr, name) == false) {
3599 snprintf(dlns->name, sizeof dlns->name, name);
3600 LD_LOGI("dlns_init dlns->name:%{public}s .", dlns->name);
3603 int dlns_get(const char *name, Dl_namespace *dlns)
3612 if (!name) {
3617 (void)snprintf(dlns->name, sizeof dlns->name, ns->ns_name);
3618 LD_LOGI("dlns_get name is null, current dlns dlns->name:%{public}s.", dlns->name);
3620 ns = find_ns_by_name(name);
3622 (void)snprintf(dlns->name, sizeof dlns->name, ns->ns_name);
3623 LD_LOGI("dlns_get found ns, current dlns dlns->name:%{public}s.", dlns->name);
3625 LD_LOGI("dlns_get not found ns! name:%{public}s.", name);
3636 if (is_permitted(caller_addr, dlns->name) == false) {
3642 LD_LOGI("dlopen_ns file:%{public}s, mode:%{public}x , caller_addr:%{public}p , dlns->name:%{public}s.",
3646 dlns ? dlns->name : "NULL");
3647 return dlopen_impl(file, mode, dlns->name, caller_addr, NULL);
3653 if (is_permitted(caller_addr, dlns->name) == false) {
3660 "dlns->name:%{public}s. , extinfo->flag:%{public}x",
3664 dlns->name,
3666 return dlopen_impl(file, mode, dlns->name, caller_addr, extinfo);
3679 if (is_permitted(caller_addr, dlns->name) == false) {
3684 ns = find_ns_by_name(dlns->name);
3696 ns_set_name(ns, dlns->name);
3740 if (is_permitted(caller_addr, dlns->name) == false) {
3745 ns_t* ns = find_ns_by_name(dlns->name);
3746 ns_t* ns_inherited = find_ns_by_name(inherited->name);
3838 (p == NULL ? "NULL" : p->name), s, v);
3840 s, strlen(v) > 0 ? v : "null", (p == NULL ? "NULL" : p->name));
3862 LD_LOGD("[dlclose]: skip unload %{public}s because it's not loaded by dlopen", p->name);
3868 LD_LOGD("[dlclose]: skip unload %{public}s because flags is RTLD_NODELETE", p->name);
3875 LD_LOGD("[dlclose]: skip unload %{public}s because nr_dlopen=%{public}d > 0", p->name, p->nr_dlopen);
3910 trace_marker_begin(HITRACE_TAG_MUSL, "dlclose", p->name);
4003 p->name, p->name);
4013 p->deps[i]->name, p->name);
4066 LD_LOGE("[dlclose]: unload %{public}s succeed when dlclose %{public}s", ef->dso->name, p->name);
4079 p->deps[deps_num]->name, p->name, p->deps[deps_num]->nr_dlopen,
4101 trace_marker_begin(HITRACE_TAG_MUSL, "calling destructors:", ef->dso->name);
4230 info->dli_fname = p->name;
4300 /* Map the symbol name to a time64 version of itself according to the
4312 /* Use the presence of the remapped symbol name in libc to determine
4328 info.dlpi_name = current->name;
4363 int dlns_set_namespace_lib_path(const char * name, const char * lib_path)
4365 if (!name || !lib_path) {
4366 LD_LOGE("dlns_set_namespace_lib_path name or lib_path is null.");
4372 if (is_permitted(caller_addr, name) == false) {
4377 ns_t* ns = find_ns_by_name(name);
4380 LD_LOGE("dlns_set_namespace_lib_path fail, input ns name : [%{public}s] is not found.", name);
4389 int dlns_set_namespace_separated(const char * name, const bool separated)
4391 if (!name) {
4392 LD_LOGE("dlns_set_namespace_separated name is null.");
4398 if (is_permitted(caller_addr, name) == false) {
4403 ns_t* ns = find_ns_by_name(name);
4406 LD_LOGE("dlns_set_namespace_separated fail, input ns name : [%{public}s] is not found.", name);
4415 int dlns_set_namespace_permitted_paths(const char * name, const char * permitted_paths)
4417 if (!name || !permitted_paths) {
4418 LD_LOGE("dlns_set_namespace_permitted_paths name or permitted_paths is null.");
4424 if (is_permitted(caller_addr, name) == false) {
4429 ns_t* ns = find_ns_by_name(name);
4432 LD_LOGE("dlns_set_namespace_permitted_paths fail, input ns name : [%{public}s] is not found.", name);
4441 int dlns_set_namespace_allowed_libs(const char * name, const char * allowed_libs)
4443 if (!name || !allowed_libs) {
4444 LD_LOGE("dlns_set_namespace_allowed_libs name or allowed_libs is null.");
4450 if (is_permitted(caller_addr, name) == false) {
4455 ns_t* ns = find_ns_by_name(name);
4458 LD_LOGE("dlns_set_namespace_allowed_libs fail, input ns name : [%{public}s] is not found.", name);
4467 int handle_asan_path_open(int fd, const char *name, ns_t *namespace, char *buf, size_t buf_size)
4469 LD_LOGD("handle_asan_path_open fd:%{public}d, name:%{public}s , namespace:%{public}s .",
4471 name,
4482 fd_tmp = path_open(name, new_lib_paths, buf, buf_size);
4486 fd_tmp = path_open(name, namespace->asan_lib_paths, buf, buf_size);
4491 fd_tmp = path_open(name, namespace->lib_paths, buf, buf_size);
4519 static void open_library_by_path(const char *name, const char *s, struct loadtask *task, struct zip_info *z_info)
4528 if (snprintf(buf, buf_size, "%.*s/%s", (int)l, s, name) < buf_size) {
4548 static void handle_asan_path_open_by_task(int fd, const char *name, ns_t *namespace, struct loadtask *task,
4551 LD_LOGD("handle_asan_path_open_by_task fd:%{public}d, name:%{public}s , namespace:%{public}s .",
4553 name,
4563 open_library_by_path(name, new_lib_paths, task, z_info);
4569 open_library_by_path(name, namespace->asan_lib_paths, task, z_info);
4574 open_library_by_path(name, namespace->lib_paths, task, z_info);
4658 LD_LOGE("Open uncompressed library: fread file name failed.");
4718 LD_LOGE("Error mapping header %{public}s: failed to read fd errno: %{public}d", task->name, errno);
4722 LD_LOGE("Error mapping header %{public}s: invaliled Ehdr l=%{public}d", task->name, l);
4729 LD_LOGE("Error mapping header %{public}s: failed to alloc memory errno: %{public}d", task->name, errno);
4734 LD_LOGE("Error mapping header %{public}s: failed to pread errno: %{public}d", task->name, errno);
4738 LD_LOGE("Error mapping header %{public}s: unmatched phsize errno: %{public}d", task->name, errno);
4745 LD_LOGE("Error mapping header %{public}s: failed to pread errno: %{public}d", task->name, errno);
4749 LD_LOGE("Error mapping header %{public}s: unmatched phsize", task->name);
4779 LD_LOGE("Error mapping header %{public}s: failed to map dynamic section errno: %{public}d", task->name, errno);
4787 LD_LOGE("Error mapping header %{public}s: DT_STRTAB not found", task->name);
4793 LD_LOGE("Error mapping header %{public}s: DT_STRSZ not found", task->name);
4805 task->name, errno);
4819 task->name, errno);
4826 LD_LOGE("Error mapping header %{public}s: dynamic section not found", task->name);
4884 LD_LOGE("Error mapping library: !task->dyn dynamic section not found task->name=%{public}s", task->name);
4906 LD_LOGE("Error mapping library: PT_LOAD mmap failed task->name=%{public}s errno=%{public}d map_len=%{public}d",
4907 task->name, errno, ph->p_memsz + (ph->p_vaddr & PAGE_SIZE - 1));
4949 LD_LOGE("Error mapping library: map len is larger than reserved address task->name=%{public}s", task->name);
4974 " task->fd=%{public}d task->name=%{public}s map_len=%{public}d",
4975 errno, DL_NOMMU_SUPPORT, task->fd, task->name, map_len);
5004 "task->fd=%{public}d task->name=%{public}s map_len=%{public}d",
5005 errno, DL_NOMMU_SUPPORT, task->fd, task->name, map_len);
5014 LD_LOGE("Error mapping library: ET_DYN task->name=%{public}s", task->name);
5050 LD_LOGE("Error mapping library: mmap fix failed task->name=%{public}s errno=%{public}d", task->name, errno);
5067 LD_LOGE("Error mapping library: PF_W mmap fix failed errno=%{public}d task->name=%{public}s zeromap_size=%{public}d",
5068 errno, task->name, zeromap_size);
5071 set_bss_vma_name(task->p->name, (void *)pgbrk, zeromap_size);
5077 LD_LOGE("Error mapping library: mprotect failed task->name=%{public}s errno=%{public}d", task->name, errno);
5132 const char *name = task->name;
5144 if (!*name) {
5150 if (name[NAME_INDEX_ZERO] == 'l' && name[NAME_INDEX_ONE] == 'i' && name[NAME_INDEX_TWO] == 'b') {
5156 if (strncmp(name + NAME_INDEX_THREE, rp, next - rp) == 0) {
5169 name, ldso.name,
5176 if (!strcmp(name, ldso.name)) {
5191 if (strchr(name, '/')) {
5192 char *separator = strstr(name, ZIP_FILE_PATH_SEPARATOR);
5194 int res = open_uncompressed_library_in_zipfile(name, &z_info, separator);
5196 task->pathname = name;
5206 LD_LOGE("Open uncompressed library in zip file failed, name:%{public}s res:%{public}d", name, res);
5210 task->pathname = name;
5216 task->fd = open(name, O_RDONLY | O_CLOEXEC);
5220 /* Search for the name to see if it's already loaded */
5222 task->p = find_library_by_name(name, namespace, check_inherited);
5225 LD_LOGD("find_library_by_name(name=%{public}s ns=%{public}s) already loaded by %{public}s in %{public}s namespace ",
5226 name, namespace->ns_name, task->p->name, task->p->namespace->ns_name);
5229 if (strlen(name) > NAME_MAX) {
5230 LD_LOGE("load_library name length is larger than NAME_MAX:%{public}s.", name);
5235 open_library_by_path(name, namespace->env_paths, task, &z_info);
5242 open_library_by_path(name, task->p->rpath, task, &z_info);
5245 LD_LOGE("Open library: check ns accessible failed, name %{public}s namespace %{public}s.",
5246 name, namespace ? namespace->ns_name : "NULL");
5254 handle_asan_path_open_by_task(task->fd, name, namespace, task, &z_info);
5258 open_library_by_path(name, namespace->lib_paths, task, &z_info);
5267 task->name, namespace->ns_name, errno);
5273 if (strchr(name, '/') == 0 && !is_sharable(inherit, name)) {
5283 task->name, namespace->ns_name);
5288 LD_LOGE("Error loading header %{public}s: failed to get file state errno=%{public}d", task->name, errno);
5298 * setup its shortname so it can be found by name. */
5299 if (!task->p->shortname && task->pathname != name) {
5300 task->p->shortname = strrchr(task->p->name, '/') + 1;
5305 LD_LOGD("find_library_by_fstat(name=%{public}s ns=%{public}s) already loaded by %{public}s in %{public}s namespace ",
5306 name, namespace->ns_name, task->p->name, task->p->namespace->ns_name);
5312 LD_LOGE("Error loading header %{public}s: failed to map header", task->name);
5335 LD_LOGE("Error loading header %{public}s: failed to allocate dso", task->name);
5344 task->p->name = task->p->buf;
5345 strcpy(task->p->name, task->pathname);
5356 /* Add a shortname only if name arg was not an explicit pathname. */
5357 if (task->pathname != name) {
5358 task->p->shortname = strrchr(task->p->name, '/') + 1;
5364 (uintptr_t)(task->p->name + strlen(task->p->name) + sizeof(size_t)));
5380 LD_LOGD("load_library loading ns=%{public}s name=%{public}s by_dlopen=%{public}d", task->namespace->ns_name, task->p->name, runtime);
5386 task->name, noload, errno);
5387 error("Error loading library %s: failed to map library noload=%d errno=%d", task->name, noload, errno);
5403 free((void*)task->name);
5404 task->name = ld_strdup("libc.so");
5407 LD_LOGE("Error loading library %{public}s: failed to load libc.so", task->name);
5408 error("Error loading library %s: failed to load libc.so", task->name);
5430 dprintf(1, "\t%s => %s (%p)\n", task->name, task->pathname, task->p->base);
5463 LD_LOGE("Error loading dependencies for %{public}s", p->name);
5464 error("Error loading dependencies for %s", p->name);
5480 LD_LOGD("load_library %{public}s adding DT_NEEDED task %{public}s namespace(%{public}s)", p->name, dtneed_name, namespace->ns_name);
5483 LD_LOGE("Error loading dependencies %{public}s : create load task failed", p->name);
5484 error("Error loading dependencies for %s : create load task failed", p->name);
5490 LD_LOGD("loading shared library %{public}s: (needed by %{public}s)", p->strings + p->dynv[i+1], p->name);
5496 p->name);
5498 p->strings + p->dynv[i + 1], p->name);
5638 LD_LOGE("Error serializing relro %{public}s: failed to write GNU_RELRO", dso->name);
5654 LD_LOGE("Error serializing relro %{public}s: failed to map GNU_RELRO", dso->name);
5666 LD_LOGE("Error mapping relro %{public}s: failed to get file state", dso->name);
5674 LD_LOGE("Error mapping relro %{public}s: failed to map fd", dso->name);
5684 LD_LOGE("Error mapping relro %{public}s: invalid file size", dso->name);
5712 LD_LOGE("Error mapping relro %{public}s: failed to map GNU_RELRO", dso->name);
5731 LD_LOGD("Serializing GNU_RELRO %{public}s", p->name);
5733 LD_LOGE("Error serializing GNU_RELRO %{public}s", p->name);
5738 LD_LOGD("Mapping GNU_RELRO %{public}s", p->name);
5740 LD_LOGE("Error mapping GNU_RELRO %{public}s", p->name);
5775 set_bss_vma_name(p->name, (void *)seg_file_end, zeromap_size);
5820 LD_LOGE("malloc error! dso name: %{public}s.", so->name);
5828 debug_info->name = so->name;