sysdeps/linux-gnu/proc.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2011,2012 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2010 Zachary T Welch, CodeSourcery
   5  * Copyright (C) 2010 Joe Damato
   6  * Copyright (C) 1998,2008,2009 Juan Cespedes
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  */
  23
  24 #define _GNU_SOURCE /* For getline.  */
  25 #include "config.h"
  26
  27 #include <sys/stat.h>
  28 #include <sys/syscall.h>
  29 #include <sys/types.h>
  30 #include <ctype.h>
  31 #include <dirent.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <inttypes.h>
  35 #include <link.h>
  36 #include <signal.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 #include "backend.h"
  43 #include "breakpoint.h"
  44 #include "config.h"
  45 #include "debug.h"
  46 #include "events.h"
  47 #include "library.h"
  48 #include "ltrace-elf.h"
  49 #include "proc.h"
  50
  51 /* /proc/pid doesn't exist just after the fork, and sometimes `ltrace'
  52  * couldn't open it to find the executable.  So it may be necessary to
  53  * have a bit delay
  54  */
  55
  56 #define MAX_DELAY       100000  /* 100000 microseconds = 0.1 seconds */
  57
  58 #define PROC_PID_FILE(VAR, FORMAT, PID)         \
  59         char VAR[strlen(FORMAT) + 6];           \
  60         sprintf(VAR, FORMAT, PID)
  61
  62 /*
  63  * Returns a (malloc'd) file name corresponding to a running pid
  64  */
  65 char *
  66 pid2name(pid_t pid) {
  67         if (!kill(pid, 0)) {
  68                 int delay = 0;
  69
  70                 PROC_PID_FILE(proc_exe, "/proc/%d/exe", pid);
  71
  72                 while (delay < MAX_DELAY) {
  73                         if (!access(proc_exe, F_OK)) {
  74                                 return strdup(proc_exe);
  75                         }
  76                         delay += 1000;  /* 1 milisecond */
  77                 }
  78         }
  79         return NULL;
  80 }
  81
  82 static FILE *
  83 open_status_file(pid_t pid)
  84 {
  85         PROC_PID_FILE(fn, "/proc/%d/status", pid);
  86         /* Don't complain if we fail.  This would typically happen
  87            when the process is about to terminate, and these files are
  88            not available anymore.  This function is called from the
  89            event loop, and we don't want to clutter the output just
  90            because the process terminates.  */
  91         return fopen(fn, "r");
  92 }
  93
  94 static char *
  95 find_line_starting(FILE * file, const char * prefix, size_t len)
  96 {
  97         char * line = NULL;
  98         size_t line_len = 0;
  99         while (!feof(file)) {
 100                 if (getline(&line, &line_len, file) < 0)
 101                         return NULL;
 102                 if (strncmp(line, prefix, len) == 0)
 103                         return line;
 104         }
 105         return NULL;
 106 }
 107
 108 static void
 109 each_line_starting(FILE *file, const char *prefix,
 110                    enum callback_status (*cb)(const char *line,
 111                                               const char *prefix,
 112                                               void *data),
 113                    void *data)
 114 {
 115         size_t len = strlen(prefix);
 116         char * line;
 117         while ((line = find_line_starting(file, prefix, len)) != NULL) {
 118                 enum callback_status st = (*cb)(line, prefix, data);
 119                 free(line);
 120                 if (st == CBS_STOP)
 121                         return;
 122         }
 123 }
 124
 125 static enum callback_status
 126 process_leader_cb(const char *line, const char *prefix, void *data)
 127 {
 128         pid_t * pidp = data;
 129         *pidp = atoi(line + strlen(prefix));
 130         return CBS_STOP;
 131 }
 132
 133 pid_t
 134 process_leader(pid_t pid)
 135 {
 136         pid_t tgid = 0;
 137         FILE * file = open_status_file(pid);
 138         if (file != NULL) {
 139                 each_line_starting(file, "Tgid:\t", &process_leader_cb, &tgid);
 140                 fclose(file);
 141         }
 142
 143         return tgid;
 144 }
 145
 146 static enum callback_status
 147 process_stopped_cb(const char *line, const char *prefix, void *data)
 148 {
 149         char c = line[strlen(prefix)];
 150         // t:tracing stop, T:job control stop
 151         *(int *)data = (c == 't' || c == 'T');
 152         return CBS_STOP;
 153 }
 154
 155 int
 156 process_stopped(pid_t pid)
 157 {
 158         int is_stopped = -1;
 159         FILE * file = open_status_file(pid);
 160         if (file != NULL) {
 161                 each_line_starting(file, "State:\t", &process_stopped_cb,
 162                                    &is_stopped);
 163                 fclose(file);
 164         }
 165         return is_stopped;
 166 }
 167
 168 static enum callback_status
 169 process_status_cb(const char *line, const char *prefix, void *data)
 170 {
 171         const char * status = line + strlen(prefix);
 172         const char c = *status;
 173
 174 #define RETURN(C) do {                                  \
 175                 *(enum process_status *)data = C;       \
 176                 return CBS_STOP;                        \
 177         } while (0)
 178
 179         switch (c) {
 180         case 'Z': RETURN(ps_zombie);
 181         case 't': RETURN(ps_tracing_stop);
 182         case 'T':
 183                 /* This can be either "T (stopped)" or, for older
 184                  * kernels, "T (tracing stop)".  */
 185                 if (!strcmp(status, "T (stopped)\n"))
 186                         RETURN(ps_stop);
 187                 else if (!strcmp(status, "T (tracing stop)\n"))
 188                         RETURN(ps_tracing_stop);
 189                 else {
 190                         fprintf(stderr, "Unknown process status: %s",
 191                                 status);
 192                         RETURN(ps_stop); /* Some sort of stop
 193                                           * anyway.  */
 194                 }
 195         case 'D':
 196         case 'S': RETURN(ps_sleeping);
 197         }
 198
 199         RETURN(ps_other);
 200 #undef RETURN
 201 }
 202
 203 enum process_status
 204 process_status(pid_t pid)
 205 {
 206         enum process_status ret = ps_invalid;
 207         FILE * file = open_status_file(pid);
 208         if (file != NULL) {
 209                 each_line_starting(file, "State:\t", &process_status_cb, &ret);
 210                 fclose(file);
 211                 if (ret == ps_invalid)
 212                         fprintf(stderr, "process_status %d: %s", pid,
 213                                 strerror(errno));
 214         } else
 215                 /* If the file is not present, the process presumably
 216                  * exited already.  */
 217                 ret = ps_zombie;
 218
 219         return ret;
 220 }
 221
 222 static int
 223 all_digits(const char *str)
 224 {
 225         while (isdigit(*str))
 226                 str++;
 227         return !*str;
 228 }
 229
 230 int
 231 process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n)
 232 {
 233         PROC_PID_FILE(fn, "/proc/%d/task", pid);
 234         DIR * d = opendir(fn);
 235         if (d == NULL)
 236                 return -1;
 237
 238         pid_t *tasks = NULL;
 239         size_t n = 0;
 240         size_t alloc = 0;
 241
 242         while (1) {
 243                 struct dirent entry;
 244                 struct dirent *result;
 245                 if (readdir_r(d, &entry, &result) != 0) {
 246                         free(tasks);
 247                         return -1;
 248                 }
 249                 if (result == NULL)
 250                         break;
 251                 if (result->d_type == DT_DIR && all_digits(result->d_name)) {
 252                         pid_t npid = atoi(result->d_name);
 253                         if (n >= alloc) {
 254                                 alloc = alloc > 0 ? (2 * alloc) : 8;
 255                                 pid_t *ntasks = realloc(tasks,
 256                                                         sizeof(*tasks) * alloc);
 257                                 if (ntasks == NULL) {
 258                                         free(tasks);
 259                                         return -1;
 260                                 }
 261                                 tasks = ntasks;
 262                         }
 263                         if (n >= alloc)
 264                                 abort();
 265                         tasks[n++] = npid;
 266                 }
 267         }
 268
 269         closedir(d);
 270
 271         *ret_tasks = tasks;
 272         *ret_n = n;
 273         return 0;
 274 }
 275
 276 /* On native 64-bit system, we need to be careful when handling cross
 277  * tracing.  This select appropriate pointer depending on host and
 278  * target architectures.  XXX Really we should abstract this into the
 279  * ABI object, as theorized about somewhere on pmachata/revamp
 280  * branch.  */
 281 static void *
 282 select_32_64(struct Process *proc, void *p32, void *p64)
 283 {
 284         if (sizeof(long) == 4 || proc->mask_32bit)
 285                 return p32;
 286         else
 287                 return p64;
 288 }
 289
 290 static int
 291 fetch_dyn64(struct Process *proc, arch_addr_t *addr, Elf64_Dyn *ret)
 292 {
 293         if (umovebytes(proc, *addr, ret, sizeof(*ret)) != sizeof(*ret))
 294                 return -1;
 295         *addr += sizeof(*ret);
 296         return 0;
 297 }
 298
 299 static int
 300 fetch_dyn32(struct Process *proc, arch_addr_t *addr, Elf64_Dyn *ret)
 301 {
 302         Elf32_Dyn dyn;
 303         if (umovebytes(proc, *addr, &dyn, sizeof(dyn)) != sizeof(dyn))
 304                 return -1;
 305
 306         *addr += sizeof(dyn);
 307         ret->d_tag = dyn.d_tag;
 308         ret->d_un.d_val = dyn.d_un.d_val;
 309
 310         return 0;
 311 }
 312
 313 static int (*
 314 dyn_fetcher(struct Process *proc))(struct Process *,
 315                                    arch_addr_t *, Elf64_Dyn *)
 316 {
 317         return select_32_64(proc, fetch_dyn32, fetch_dyn64);
 318 }
 319
 320 int
 321 proc_find_dynamic_entry_addr(struct Process *proc, arch_addr_t src_addr,
 322                              int d_tag, arch_addr_t *ret)
 323 {
 324         debug(DEBUG_FUNCTION, "find_dynamic_entry()");
 325
 326         if (ret == NULL || src_addr == 0 || d_tag < 0)
 327                 return -1;
 328
 329         int i = 0;
 330         while (1) {
 331                 Elf64_Dyn entry;
 332                 if (dyn_fetcher(proc)(proc, &src_addr, &entry) < 0
 333                     || entry.d_tag == DT_NULL
 334                     || i++ > 100) { /* Arbitrary cut-off so that we
 335                                      * don't loop forever if the
 336                                      * binary is corrupted.  */
 337                         debug(2, "Couldn't find address for dtag!");
 338                         return -1;
 339                 }
 340
 341                 if (entry.d_tag == d_tag) {
 342                         /* XXX The double cast should be removed when
 343                          * arch_addr_t becomes integral type.  */
 344                         *ret = (arch_addr_t)(uintptr_t)entry.d_un.d_val;
 345                         debug(2, "found address: %p in dtag %d", *ret, d_tag);
 346                         return 0;
 347                 }
 348         }
 349 }
 350
 351 /* Our own type for representing 32-bit linkmap.  We can't rely on the
 352  * definition in link.h, because that's only accurate for our host
 353  * architecture, not for target architecture (where the traced process
 354  * runs). */
 355 #define LT_LINK_MAP(BITS)                       \
 356         {                                       \
 357                 Elf##BITS##_Addr l_addr;        \
 358                 Elf##BITS##_Addr l_name;        \
 359                 Elf##BITS##_Addr l_ld;          \
 360                 Elf##BITS##_Addr l_next;        \
 361                 Elf##BITS##_Addr l_prev;        \
 362         }
 363 struct lt_link_map_32 LT_LINK_MAP(32);
 364 struct lt_link_map_64 LT_LINK_MAP(64);
 365
 366 static int
 367 fetch_lm64(struct Process *proc, arch_addr_t addr,
 368            struct lt_link_map_64 *ret)
 369 {
 370         if (umovebytes(proc, addr, ret, sizeof(*ret)) != sizeof(*ret))
 371                 return -1;
 372         return 0;
 373 }
 374
 375 static int
 376 fetch_lm32(struct Process *proc, arch_addr_t addr,
 377            struct lt_link_map_64 *ret)
 378 {
 379         struct lt_link_map_32 lm;
 380         if (umovebytes(proc, addr, &lm, sizeof(lm)) != sizeof(lm))
 381                 return -1;
 382
 383         ret->l_addr = lm.l_addr;
 384         ret->l_name = lm.l_name;
 385         ret->l_ld = lm.l_ld;
 386         ret->l_next = lm.l_next;
 387         ret->l_prev = lm.l_prev;
 388
 389         return 0;
 390 }
 391
 392 static int (*
 393 lm_fetcher(struct Process *proc))(struct Process *,
 394                                   arch_addr_t, struct lt_link_map_64 *)
 395 {
 396         return select_32_64(proc, fetch_lm32, fetch_lm64);
 397 }
 398
 399 /* The same as above holds for struct r_debug.  */
 400 #define LT_R_DEBUG(BITS)                        \
 401         {                                       \
 402                 int r_version;                  \
 403                 Elf##BITS##_Addr r_map;         \
 404                 Elf##BITS##_Addr r_brk;         \
 405                 int r_state;                    \
 406                 Elf##BITS##_Addr r_ldbase;      \
 407         }
 408
 409 struct lt_r_debug_32 LT_R_DEBUG(32);
 410 struct lt_r_debug_64 LT_R_DEBUG(64);
 411
 412 static int
 413 fetch_rd64(struct Process *proc, arch_addr_t addr,
 414            struct lt_r_debug_64 *ret)
 415 {
 416         if (umovebytes(proc, addr, ret, sizeof(*ret)) != sizeof(*ret))
 417                 return -1;
 418         return 0;
 419 }
 420
 421 static int
 422 fetch_rd32(struct Process *proc, arch_addr_t addr,
 423            struct lt_r_debug_64 *ret)
 424 {
 425         struct lt_r_debug_32 rd;
 426         if (umovebytes(proc, addr, &rd, sizeof(rd)) != sizeof(rd))
 427                 return -1;
 428
 429         ret->r_version = rd.r_version;
 430         ret->r_map = rd.r_map;
 431         ret->r_brk = rd.r_brk;
 432         ret->r_state = rd.r_state;
 433         ret->r_ldbase = rd.r_ldbase;
 434
 435         return 0;
 436 }
 437
 438 static int (*
 439 rdebug_fetcher(struct Process *proc))(struct Process *,
 440                                       arch_addr_t, struct lt_r_debug_64 *)
 441 {
 442         return select_32_64(proc, fetch_rd32, fetch_rd64);
 443 }
 444
 445 static int
 446 fetch_auxv64_entry(int fd, Elf64_auxv_t *ret)
 447 {
 448         /* Reaching EOF is as much problem as not reading whole
 449          * entry.  */
 450         return read(fd, ret, sizeof(*ret)) == sizeof(*ret) ? 0 : -1;
 451 }
 452
 453 static int
 454 fetch_auxv32_entry(int fd, Elf64_auxv_t *ret)
 455 {
 456         Elf32_auxv_t auxv;
 457         if (read(fd, &auxv, sizeof(auxv)) != sizeof(auxv))
 458                 return -1;
 459
 460         ret->a_type = auxv.a_type;
 461         ret->a_un.a_val = auxv.a_un.a_val;
 462         return 0;
 463 }
 464
 465 static int (*
 466 auxv_fetcher(struct Process *proc))(int, Elf64_auxv_t *)
 467 {
 468         return select_32_64(proc, fetch_auxv32_entry, fetch_auxv64_entry);
 469 }
 470
 471 static void
 472 crawl_linkmap(struct Process *proc, struct lt_r_debug_64 *dbg)
 473 {
 474         debug (DEBUG_FUNCTION, "crawl_linkmap()");
 475
 476         if (!dbg || !dbg->r_map) {
 477                 debug(2, "Debug structure or it's linkmap are NULL!");
 478                 return;
 479         }
 480
 481         /* XXX The double cast should be removed when
 482          * arch_addr_t becomes integral type.  */
 483         arch_addr_t addr = (arch_addr_t)(uintptr_t)dbg->r_map;
 484
 485         while (addr != 0) {
 486                 struct lt_link_map_64 rlm;
 487                 if (lm_fetcher(proc)(proc, addr, &rlm) < 0) {
 488                         debug(2, "Unable to read link map");
 489                         return;
 490                 }
 491
 492                 arch_addr_t key = addr;
 493                 /* XXX The double cast should be removed when
 494                  * arch_addr_t becomes integral type.  */
 495                 addr = (arch_addr_t)(uintptr_t)rlm.l_next;
 496                 if (rlm.l_name == 0) {
 497                         debug(2, "Name of mapped library is NULL");
 498                         return;
 499                 }
 500
 501                 char lib_name[BUFSIZ];
 502                 /* XXX The double cast should be removed when
 503                  * arch_addr_t becomes integral type.  */
 504                 umovebytes(proc, (arch_addr_t)(uintptr_t)rlm.l_name,
 505                            lib_name, sizeof(lib_name));
 506
 507                 /* Library name can be an empty string, in which case
 508                  * the entry represents either the main binary, or a
 509                  * VDSO.  Unfortunately we can't rely on that, as in
 510                  * recent glibc, that entry is initialized to VDSO
 511                  * SONAME.
 512                  *
 513                  * It's not clear how to detect VDSO in this case.  We
 514                  * can't assume that l_name of real DSOs will be
 515                  * either absolute or relative (for LD_LIBRARY_PATH=:
 516                  * it will be neither).  We can't compare l_addr with
 517                  * AT_SYSINFO_EHDR either, as l_addr is bias (which
 518                  * also means it's not unique, and therefore useless
 519                  * for this).  We could load VDSO from process image
 520                  * and at least compare actual SONAMEs.  For now, this
 521                  * kludge is about the best that we can do.  */
 522                 if (*lib_name == 0
 523                     || strcmp(lib_name, "linux-vdso.so.1") == 0
 524                     || strcmp(lib_name, "linux-gate.so.1") == 0
 525                     || strcmp(lib_name, "linux-vdso32.so.1") == 0
 526                     || strcmp(lib_name, "linux-vdso64.so.1") == 0)
 527                         continue;
 528
 529                 /* Do we have that library already?  */
 530                 if (proc_each_library(proc, NULL, library_with_key_cb, &key))
 531                         continue;
 532
 533                 struct library *lib = malloc(sizeof(*lib));
 534                 if (lib == NULL) {
 535                 fail:
 536                         if (lib != NULL)
 537                                 library_destroy(lib);
 538                         fprintf(stderr, "Couldn't load ELF object %s: %s\n",
 539                                 lib_name, strerror(errno));
 540                         continue;
 541                 }
 542                 library_init(lib, LT_LIBTYPE_DSO);
 543
 544                 if (ltelf_read_library(lib, proc, lib_name, rlm.l_addr) < 0)
 545                         goto fail;
 546
 547                 lib->key = key;
 548                 proc_add_library(proc, lib);
 549         }
 550         return;
 551 }
 552
 553 static int
 554 load_debug_struct(struct Process *proc, struct lt_r_debug_64 *ret)
 555 {
 556         debug(DEBUG_FUNCTION, "load_debug_struct");
 557
 558         if (rdebug_fetcher(proc)(proc, proc->os.debug_addr, ret) < 0) {
 559                 debug(2, "This process does not have a debug structure!");
 560                 return -1;
 561         }
 562
 563         return 0;
 564 }
 565
 566 static void
 567 rdebug_bp_on_hit(struct breakpoint *bp, struct Process *proc)
 568 {
 569         debug(DEBUG_FUNCTION, "arch_check_dbg");
 570
 571         struct lt_r_debug_64 rdbg;
 572         if (load_debug_struct(proc, &rdbg) < 0) {
 573                 debug(2, "Unable to load debug structure!");
 574                 return;
 575         }
 576
 577         if (rdbg.r_state == RT_CONSISTENT) {
 578                 debug(2, "Linkmap is now consistent");
 579                 switch (proc->os.debug_state) {
 580                 case RT_ADD:
 581                         debug(2, "Adding DSO to linkmap");
 582                         crawl_linkmap(proc, &rdbg);
 583                         break;
 584                 case RT_DELETE:
 585                         debug(2, "Removing DSO from linkmap");
 586                         // XXX unload that library
 587                         break;
 588                 default:
 589                         debug(2, "Unexpected debug state!");
 590                 }
 591         }
 592
 593         proc->os.debug_state = rdbg.r_state;
 594 }
 595
 596 #ifndef ARCH_HAVE_FIND_DL_DEBUG
 597 int
 598 arch_find_dl_debug(struct Process *proc, arch_addr_t dyn_addr,
 599                    arch_addr_t *ret)
 600 {
 601         return proc_find_dynamic_entry_addr(proc, dyn_addr, DT_DEBUG, ret);
 602 }
 603 #endif
 604
 605 int
 606 linkmap_init(struct Process *proc, arch_addr_t dyn_addr)
 607 {
 608         debug(DEBUG_FUNCTION, "linkmap_init(%d, dyn_addr=%p)", proc->pid, dyn_addr);
 609
 610         if (arch_find_dl_debug(proc, dyn_addr, &proc->os.debug_addr) == -1) {
 611                 debug(2, "Couldn't find debug structure!");
 612                 return -1;
 613         }
 614
 615         int status;
 616         struct lt_r_debug_64 rdbg;
 617         if ((status = load_debug_struct(proc, &rdbg)) < 0) {
 618                 debug(2, "No debug structure or no memory to allocate one!");
 619                 return status;
 620         }
 621
 622         /* XXX The double cast should be removed when
 623          * arch_addr_t becomes integral type.  */
 624         arch_addr_t addr = (arch_addr_t)(uintptr_t)rdbg.r_brk;
 625         if (arch_translate_address_dyn(proc, addr, &addr) < 0)
 626                 return -1;
 627
 628         struct breakpoint *rdebug_bp = insert_breakpoint(proc, addr, NULL);
 629         static struct bp_callbacks rdebug_callbacks = {
 630                 .on_hit = rdebug_bp_on_hit,
 631         };
 632         rdebug_bp->cbs = &rdebug_callbacks;
 633
 634         crawl_linkmap(proc, &rdbg);
 635
 636         return 0;
 637 }
 638
 639 int
 640 task_kill (pid_t pid, int sig)
 641 {
 642         // Taken from GDB
 643         int ret;
 644
 645         errno = 0;
 646         ret = syscall (__NR_tkill, pid, sig);
 647         return ret;
 648 }
 649
 650 void
 651 process_removed(struct Process *proc)
 652 {
 653         delete_events_for(proc);
 654 }
 655
 656 int
 657 process_get_entry(struct Process *proc,
 658                   arch_addr_t *entryp,
 659                   arch_addr_t *interp_biasp)
 660 {
 661         PROC_PID_FILE(fn, "/proc/%d/auxv", proc->pid);
 662         int fd = open(fn, O_RDONLY);
 663         int ret = 0;
 664         if (fd == -1) {
 665         fail:
 666                 fprintf(stderr, "couldn't read %s: %s", fn, strerror(errno));
 667                 ret = -1;
 668         done:
 669                 if (fd != -1)
 670                         close(fd);
 671                 return ret;
 672         }
 673
 674         arch_addr_t at_entry = 0;
 675         arch_addr_t at_bias = 0;
 676         while (1) {
 677                 Elf64_auxv_t entry = {};
 678                 if (auxv_fetcher(proc)(fd, &entry) < 0)
 679                         goto fail;
 680
 681                 switch (entry.a_type) {
 682                 case AT_BASE:
 683                         /* XXX The double cast should be removed when
 684                          * arch_addr_t becomes integral type.  */
 685                         at_bias = (arch_addr_t)(uintptr_t)entry.a_un.a_val;
 686                         continue;
 687
 688                 case AT_ENTRY:
 689                         /* XXX The double cast should be removed when
 690                          * arch_addr_t becomes integral type.  */
 691                         at_entry = (arch_addr_t)(uintptr_t)entry.a_un.a_val;
 692                 default:
 693                         continue;
 694
 695                 case AT_NULL:
 696                         break;
 697                 }
 698                 break;
 699         }
 700
 701         if (entryp != NULL)
 702                 *entryp = at_entry;
 703         if (interp_biasp != NULL)
 704                 *interp_biasp = at_bias;
 705         goto done;
 706 }
 707
 708 int
 709 os_process_init(struct Process *proc)
 710 {
 711         proc->os.debug_addr = 0;
 712         proc->os.debug_state = 0;
 713         return 0;
 714 }
 715
 716 void
 717 os_process_destroy(struct Process *proc)
 718 {
 719 }
 720
 721 int
 722 os_process_clone(struct Process *retp, struct Process *proc)
 723 {
 724         retp->os = proc->os;
 725         return 0;
 726 }
 727
 728 int
 729 os_process_exec(struct Process *proc)
 730 {
 731         return 0;
 732 }