src/process.c

   1 /* -*- mode: C; c-file-style: "linux" -*- */
   2
   3 /* MemProf -- memory profiler and leak detector
   4  * Copyright 1999, 2000, 2001, Red Hat, Inc.
   5  * Copyright 2002, Kristian Rietveld
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21 /*====*/
  22
  23 #define _GNU_SOURCE
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <sys/socket.h>
  32 #include <sys/stat.h>
  33 #include <sys/wait.h>
  34 #include <sys/sysmacros.h>
  35
  36 #include <glib-object.h>
  37
  38 #include "memintercept.h"
  39 #include "memprof.h"
  40 #include "process.h"
  41 #include "server.h"
  42 #include <glib/gi18n.h>
  43
  44 enum {
  45         STATUS_CHANGED,
  46         RESET,
  47         LAST_SIGNAL
  48 };
  49 static guint process_signals[LAST_SIGNAL] = { 0 };
  50
  51 static void mp_process_class_init (MPProcessClass *class);
  52 static void mp_process_init (MPProcess *process);
  53 static void mp_process_finalize (GObject *object);
  54 static void process_reinit (MPProcess *process);
  55
  56 #define MP_PAGE_SIZE 4096
  57
  58 /* Code to keep a queue of commands read
  59  */
  60 typedef struct {
  61         MIInfo info;
  62         StackNode *stack;
  63 } Command;
  64
  65 static gint
  66 queue_compare (gconstpointer a, gconstpointer b)
  67 {
  68         const Command *commanda = a;
  69         const Command *commandb = b;
  70
  71         return (commanda->info.any.seqno < commandb->info.any.seqno ? -1 :
  72                 (commanda->info.any.seqno > commandb->info.any.seqno  ? 1 : 0));
  73 }
  74
  75 static void
  76 queue_command (MPProcess *process, MIInfo *info, StackNode *stack)
  77 {
  78         Command *command = g_new (Command, 1);
  79         command->info = *info;
  80         command->stack = stack;
  81
  82         process->command_queue = g_list_insert_sorted (process->command_queue, command, queue_compare);
  83 }
  84
  85 static gboolean
  86 unqueue_command (MPProcess *process, MIInfo *info, StackNode **stack)
  87 {
  88         Command *command = process->command_queue->data;
  89         GList *tmp_list;
  90
  91         if (command->info.any.seqno == process->seqno) {
  92                 *stack = command->stack;
  93                 *info = command->info;
  94
  95                 tmp_list = process->command_queue;
  96                 process->command_queue = g_list_remove_link (process->command_queue, tmp_list);
  97                 g_free (command);
  98                 g_list_free_1 (tmp_list);
  99
 100                 return TRUE;
 101         } else
 102                 return FALSE;
 103 }
 104
 105 /************************************************************
 106  * Block Manipulation
 107  ************************************************************/
 108
 109 void
 110 block_unref (Block *block)
 111 {
 112         block->refcount--;
 113         if (block->refcount == 0)
 114                 g_free (block);
 115 }
 116
 117 /************************************************************
 118  * Code to map addresses to object files
 119  ************************************************************/
 120 typedef struct {
 121   guint addr;
 122   guint size;
 123   gchar *name;
 124 } Symbol;
 125
 126 void
 127 prepare_map (Map *map)
 128 {
 129         g_return_if_fail (!map->prepared);
 130
 131         map->binfile = bin_file_new (map->name);
 132
 133         map->prepared = TRUE;
 134 }
 135
 136 static void
 137 process_read_maps (MPProcess *process)
 138 {
 139         gchar buffer[1024];
 140         FILE *in;
 141
 142         snprintf (buffer, 1023, "/proc/%d/maps", process->pid);
 143
 144         in = fopen (buffer, "r");
 145
 146         if (process->map_list) {
 147                 g_list_foreach (process->map_list, (GFunc)g_free, NULL);
 148                 g_list_free (process->map_list);
 149
 150                 process->map_list = NULL;
 151         }
 152
 153         while (fgets(buffer, 1023, in)) {
 154                 char file[256];
 155                 int count;
 156                 gulong start;
 157                 gulong end;
 158                 gulong offset;
 159                 gulong inode;
 160
 161                 count = sscanf (
 162                         buffer, "%lx-%lx %*15s %lx %*x:%*x %lu %255s",
 163                         &start, &end, &offset, &inode, file);
 164                 if (count == 5)
 165                 {
 166                         Map *map;
 167
 168                         map = g_new (Map, 1);
 169                         map->prepared = FALSE;
 170                         map->start = start;
 171                         map->size = end - start;
 172
 173                         map->offset = offset;
 174
 175                         map->name = g_strdup (file);
 176
 177                         process->map_list = g_list_prepend (process->map_list, map);
 178                 }
 179         }
 180
 181         fclose (in);
 182 }
 183
 184 static Map *
 185 real_locate_map (MPProcess *process, guint addr)
 186 {
 187         GList *tmp_list = process->map_list;
 188
 189         while (tmp_list)
 190         {
 191                 Map *tmp_map = tmp_list->data;
 192
 193                 if ((addr >= tmp_map->start) &&
 194                     (addr < tmp_map->start + tmp_map->size))
 195                         return tmp_map;
 196
 197                 tmp_list = tmp_list->next;
 198         }
 199
 200         return NULL;
 201 }
 202
 203 Map *
 204 locate_map (MPProcess *process, guint addr)
 205 {
 206         Map *map = real_locate_map (process, addr);
 207         if (!map)
 208         {
 209                 gpointer page_addr = (gpointer) (addr - addr % MP_PAGE_SIZE);
 210                 if (g_list_find (process->bad_pages, page_addr))
 211                         return NULL;
 212
 213                 process_read_maps (process);
 214
 215                 map = real_locate_map (process, addr);
 216
 217                 if (!map) {
 218                         process->bad_pages = g_list_prepend (process->bad_pages, page_addr);
 219                         return NULL;
 220                 }
 221         }
 222
 223         if (!map->prepared)
 224                 prepare_map (map);
 225
 226         return map;
 227 }
 228
 229 const char *
 230 process_locate_symbol (MPProcess *process, gsize addr)
 231 {
 232         Map *map = locate_map (process, addr);
 233         const BinSymbol *symbol;
 234
 235         if (!map)
 236                 return "<unknown map>";
 237
 238         addr -= map->start;
 239         addr += map->offset;
 240
 241         symbol = bin_file_lookup_symbol (map->binfile, addr);
 242
 243         return bin_symbol_get_name (map->binfile, symbol);
 244 }
 245
 246 /**
 247  * The string assigned to functionname is owned/shared
 248  * by the system and must not be freed.
 249  */
 250 gboolean
 251 process_find_line (MPProcess *process, void *address,
 252                    const char **filename, char **functionname,
 253                    unsigned int *line)
 254 {
 255         const char *s = process_locate_symbol (process, GPOINTER_TO_SIZE (address));
 256
 257         if (s)
 258         {
 259                 *filename = NULL;
 260                 *functionname = (char*)s;
 261                 *line = -1;
 262         }
 263
 264         return TRUE;
 265 }
 266
 267 void
 268 process_dump_stack (MPProcess *process, FILE *out, StackNode *stack)
 269 {
 270         for (; stack != NULL; stack = stack->parent)
 271         {
 272                 const char *filename;
 273                 char *functionname;
 274                 unsigned int line;
 275
 276                 if (process_find_line (process, stack->address,
 277                                        &filename, &functionname, &line)) {
 278                         if (filename)
 279                                 fprintf(out, "\t%s(): %s:%u\n", functionname, filename, line);
 280                         else
 281                                 fprintf(out, "\t%s()\n", functionname);
 282                 } else
 283                         fprintf(out, "\t[%p]\n", stack->address);
 284         }
 285 }
 286
 287
 288 void
 289 process_map_sections (Map *map, SectionFunc func, gpointer user_data)
 290 {
 291         /* FIXME: this should be reinstated */
 292
 293 #if 0
 294         asection *section;
 295
 296         if (map->abfd)
 297                 for (section = map->abfd->sections; section; section = section->next) {
 298                         if (strcmp (section->name, ".bss") == 0 ||
 299                             strcmp (section->name, ".data") == 0) {
 300                                 void *addr = (void *)section->vma;
 301                                 if (map->do_offset)
 302                                         addr += map->addr;
 303
 304                                 /* bfd_section_size() gives 0 for old versions of binutils, so peek
 305                                  * into the internals instead. :-(
 306                                  */
 307                                 (*func) (addr, bfd_section_size (map->abfd, section), user_data);
 308 //                              (*func) (addr, section->_cooked_size, user_data);
 309                         }
 310                 }
 311 #endif
 312 }
 313
 314 void
 315 process_sections (MPProcess *process, SectionFunc func, gpointer user_data)
 316 {
 317         GList *tmp_list;
 318
 319         process_read_maps (process);
 320
 321         tmp_list = process->map_list;
 322
 323         while (tmp_list) {
 324                 Map *map = tmp_list->data;
 325
 326                 if (!map->prepared)
 327                         prepare_map (map);
 328
 329                 process_map_sections (map, func, user_data);
 330                 tmp_list = tmp_list->next;
 331         }
 332 }
 333
 334 /************************************************************
 335  * Communication with subprocess
 336  ************************************************************/
 337
 338 static GHashTable *
 339 get_block_table (MPProcess *process)
 340 {
 341         if (!process->block_table)
 342                 process->block_table = g_hash_table_new (g_direct_hash, NULL);
 343
 344         return process->block_table;
 345
 346 }
 347
 348 static void
 349 process_free_block (gpointer key, gpointer value, gpointer data)
 350 {
 351         block_unref (value);
 352 }
 353
 354 static void
 355 process_duplicate_block (gpointer key, gpointer value, gpointer data)
 356 {
 357         GHashTable *new_table = data;
 358         Block *block = value;
 359
 360         block->refcount++;
 361
 362         g_hash_table_insert (new_table, key, value);
 363 }
 364
 365 MPProcess *
 366 process_duplicate (MPProcess *process)
 367 {
 368         MPProcess *new_process = process_new (process->server);
 369
 370         if (process->block_table) {
 371                 GHashTable *new_block_table = get_block_table(new_process);
 372
 373                 g_hash_table_foreach (process->block_table,
 374                                       process_duplicate_block,
 375                                       new_block_table);
 376         }
 377
 378         new_process->bytes_used = process->bytes_used;
 379         new_process->n_allocations = process->n_allocations;
 380         new_process->seqno = process->seqno;
 381
 382         new_process->parent = process;
 383
 384         return new_process;
 385 }
 386
 387 static void
 388 process_reinit (MPProcess *process)
 389 {
 390         process_stop_input (process);
 391
 392         if (process->input_channel) {
 393                 g_io_channel_unref (process->input_channel);
 394                 process->input_channel = NULL;
 395         }
 396
 397         process->bytes_used = 0;
 398         process->n_allocations = 0;
 399         process->seqno = 0;
 400
 401         if (process->map_list) {
 402                 g_list_foreach (process->map_list, (GFunc)g_free, NULL);
 403                 g_list_free (process->map_list);
 404
 405                 process->map_list = NULL;
 406         }
 407
 408         if (process->bad_pages) {
 409                 g_list_free (process->bad_pages);
 410                 process->bad_pages = NULL;
 411         }
 412
 413         if (process->block_table) {
 414                 g_hash_table_foreach (process->block_table, process_free_block, NULL);
 415                 g_hash_table_destroy (process->block_table);
 416                 process->block_table = NULL;
 417         }
 418
 419         if (process->stack_stash) {
 420                 stack_stash_unref (process->stack_stash);
 421                 process->stack_stash = NULL;
 422         }
 423
 424         /* FIXME: leak */
 425         process->command_queue = NULL;
 426 }
 427
 428 static StackStash *
 429 get_stack_stash (MPProcess *process)
 430 {
 431         if (!process->stack_stash)
 432                 process->stack_stash = stack_stash_new (NULL);
 433
 434         return process->stack_stash;
 435 }
 436
 437 void
 438 process_exec_reset (MPProcess *process)
 439 {
 440         process_reinit (process);
 441         g_signal_emit_by_name (process, "reset");
 442 }
 443
 444 static void
 445 process_command (MPProcess *process, MIInfo *info, StackNode *stack)
 446 {
 447         GHashTable *block_table;
 448         Block *block;
 449
 450         if (info->any.seqno != process->seqno) {
 451                 queue_command (process, info, stack);
 452                 return;
 453         }
 454
 455         process->seqno++;
 456
 457         block = NULL;
 458
 459         switch (info->operation) {
 460         case MI_NEW:
 461         case MI_FORK:
 462         case MI_CLONE:
 463         case MI_EXEC:
 464                 g_assert_not_reached ();
 465                 break;
 466
 467         case MI_EXIT:
 468                 /* Handled before, ignore */
 469                 break;
 470
 471         case MI_TIME:
 472                 info->alloc.old_ptr = NULL;
 473                 info->alloc.new_ptr = (void *)process->seqno;
 474                 info->alloc.size = 1;
 475                 /* Fall through */
 476
 477         default: /* MALLOC / REALLOC / FREE */
 478                 block_table = get_block_table (process);
 479
 480                 if (info->alloc.old_ptr != NULL) {
 481                         block = g_hash_table_lookup (block_table, info->alloc.old_ptr);
 482                         if (!block) {
 483                                 g_warning ("Block %p not found (pid=%d)!\n", info->alloc.old_ptr, process->pid);
 484                                 process_dump_stack (process, stderr, stack);
 485                         }
 486                         else {
 487                                 g_hash_table_remove (block_table, info->alloc.old_ptr);
 488                                 process->bytes_used -= block->size;
 489                                 block_unref (block);
 490
 491                                 process->n_allocations--;
 492                         }
 493                 }
 494
 495                 /* We need to lookup before inserting, because realloc() can call malloc(), so we
 496                  * see the same block twice. The same problem comes upduring malloc initialization
 497                  * where __libc_malloc() is called twice for the same block. We could optimize
 498                  * things a bit by using g_hash_table_new_full() to catch the replacement when
 499                  * it happens and free the old block, but that would make keeping track of
 500                  * process->n_allocations/bytes_used a little difficult.
 501                  */
 502
 503                 if (info->alloc.new_ptr && !g_hash_table_lookup (block_table, info->alloc.new_ptr)) {
 504                         block = g_new (Block, 1);
 505                         block->refcount = 1;
 506
 507                         block->flags = 0;
 508                         block->addr = info->alloc.new_ptr;
 509                         block->size = info->alloc.size;
 510                         block->stack = stack;
 511
 512                         process->n_allocations++;
 513                         process->bytes_used += info->alloc.size;
 514
 515                         g_hash_table_insert (block_table, info->alloc.new_ptr, block);
 516                 }
 517         }
 518
 519         while (process->command_queue && unqueue_command (process, info, &stack))
 520                 process_command (process, info, stack);
 521 }
 522
 523 static gboolean
 524 input_func (GIOChannel  *source,
 525             GIOCondition condition,
 526             gpointer     data)
 527 {
 528         MIInfo info;
 529         guint count;
 530         MPProcess *input_process = data;
 531         MPProcess *process = NULL;
 532
 533         do {
 534                 memset (&info, 0, sizeof (info));
 535                 info.operation = -1;
 536                 count = 0;
 537                 if (g_io_channel_get_flags(source) & G_IO_FLAG_IS_READABLE)
 538                         g_io_channel_read_chars (source, (char *)&info, sizeof(info), &count, NULL);
 539
 540                 if (count == 0) {
 541                         g_io_channel_unref (input_process->input_channel);
 542                         input_process->input_channel = NULL;
 543
 544                         mp_server_remove_process (input_process->server, input_process);
 545                         process_set_status (input_process, MP_PROCESS_DEFUNCT);
 546
 547                         return FALSE;
 548                 } else {
 549                         StackNode *stack = NULL;
 550
 551 //                      fprintf (stderr, "Read size %d op 0x%x\n", count, info.operation);
 552
 553                         if (info.operation == MI_MALLOC ||
 554                             info.operation == MI_REALLOC ||
 555                             info.operation == MI_FREE ||
 556                             info.operation == MI_TIME) {
 557                                 void **stack_buffer = NULL;
 558                                 StackStash *stash = get_stack_stash (input_process);
 559
 560                                 g_assert (count >= sizeof (MIInfoAlloc));
 561
 562                                 stack_buffer = g_alloca (sizeof (void *) * info.alloc.stack_size);
 563                                 g_io_channel_read_chars (source, (char *)stack_buffer, sizeof(void *) * info.alloc.stack_size, &count, NULL);
 564                                 stack = stack_stash_add_trace (stash, stack_buffer, info.alloc.stack_size, -1);
 565
 566                         } else if (info.operation == MI_EXIT) {
 567                                 process_set_status (input_process, MP_PROCESS_EXITING);
 568                                 if (input_process->clone_of)
 569                                         process_detach (input_process);
 570                         }
 571
 572                         process = input_process;
 573                         while (process->clone_of)
 574                                 process = process->clone_of;
 575
 576                         process_command (process, &info, stack);
 577
 578
 579 /*              if (info.any.pid != input_process->pid)
 580                 g_warning ("Ow! Ow! Ow: %d %d %d!", info.any.pid, input_process->pid, g_io_channel_unix_get_fd (input_process->input_channel)); */
 581
 582                 }
 583         } while (info.operation != MI_EXIT && (g_io_channel_get_buffer_condition(source) & G_IO_IN));
 584
 585         return TRUE;
 586 }
 587
 588 void
 589 process_stop_input (MPProcess *process)
 590 {
 591         g_return_if_fail (process != NULL);
 592
 593         if (process->input_tag) {
 594                 g_source_remove (process->input_tag);
 595                 process->input_tag = 0;
 596         }
 597 }
 598
 599 void
 600 process_start_input (MPProcess *process)
 601 {
 602         g_return_if_fail (process != NULL);
 603
 604         if (!process->input_tag && process->input_channel)
 605                 process->input_tag = g_io_add_watch_full (process->input_channel,
 606                                                           G_PRIORITY_LOW,
 607                                                           G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
 608                                                           input_func, process, NULL);
 609 }
 610
 611 void
 612 process_clear_input (MPProcess *process)
 613 {
 614         g_return_if_fail (process != NULL);
 615
 616         process->bytes_used = 0;
 617         process->n_allocations = 0;
 618
 619         if (process->map_list) {
 620                 g_list_foreach (process->map_list, (GFunc)g_free, NULL);
 621                 g_list_free (process->map_list);
 622
 623                 process->map_list = NULL;
 624         }
 625
 626         if (process->bad_pages) {
 627                 g_list_free (process->bad_pages);
 628                 process->bad_pages = NULL;
 629         }
 630
 631         if (process->block_table) {
 632                 g_hash_table_foreach (process->block_table, process_free_block, NULL);
 633                 g_hash_table_destroy (process->block_table);
 634                 process->block_table = NULL;
 635         }
 636
 637         if (process->stack_stash) {
 638                 stack_stash_unref (process->stack_stash);
 639                 process->stack_stash = NULL;
 640         }
 641 }
 642
 643 char *
 644 process_find_exec (char **args)
 645 {
 646         int i;
 647
 648         if (g_file_test(args[0], G_FILE_TEST_EXISTS)) {
 649                 if (!g_path_is_absolute (args[0]))
 650                         return g_strconcat ("./", args[0], NULL);
 651                 else
 652                         return g_strdup (args[0]);
 653         } else {
 654                 char **paths;
 655                 char *path = NULL;
 656                 char *pathenv = getenv ("PATH");
 657                 if (pathenv)
 658                 {
 659                         paths = g_strsplit (pathenv, ":", -1);
 660                         for (i=0; paths[i]; i++) {
 661                                 path = g_build_filename (paths[i], args[0], NULL);
 662                                 if (g_file_test (path, G_FILE_TEST_EXISTS))
 663                                         break;
 664                                 else {
 665                                         g_free (path);
 666                                         path = NULL;
 667                                 }
 668                         }
 669
 670                         g_strfreev (paths);
 671                 }
 672
 673                 return path;
 674         }
 675 }
 676
 677 char **
 678 process_parse_exec (const char *exec_string)
 679 {
 680         return g_strsplit (exec_string, " ", -1);
 681 }
 682
 683 GType
 684 mp_process_get_type (void)
 685 {
 686         static GType process_type = 0;
 687
 688         if (!process_type) {
 689                 static const GTypeInfo process_info = {
 690                         sizeof (MPProcessClass),
 691                         (GBaseInitFunc) NULL,
 692                         (GBaseFinalizeFunc) NULL,
 693                         (GClassInitFunc) mp_process_class_init,
 694                         NULL, /* class_finalize */
 695                         NULL, /* class_data */
 696                         sizeof (MPProcess),
 697                         0, /* n_preallocs */
 698                         (GInstanceInitFunc) mp_process_init
 699                 };
 700
 701                 process_type = g_type_register_static (G_TYPE_OBJECT,
 702                                                        "MPProcess",
 703                                                        &process_info, 0);
 704         }
 705
 706         return process_type;
 707 }
 708
 709 static void
 710 mp_process_class_init (MPProcessClass *class)
 711 {
 712         static gboolean initialized = FALSE;
 713
 714         GObjectClass *o_class = G_OBJECT_CLASS (class);
 715
 716         o_class->finalize = mp_process_finalize;
 717
 718         if (!initialized) {
 719                 process_signals[STATUS_CHANGED] =
 720                         g_signal_new ("status_changed",
 721                                       MP_TYPE_PROCESS,
 722                                       G_SIGNAL_RUN_LAST,
 723                                       G_STRUCT_OFFSET (MPProcessClass, status_changed),
 724                                       NULL, NULL,
 725                                       g_cclosure_marshal_VOID__VOID,
 726                                       G_TYPE_NONE, 0);
 727
 728                 process_signals[RESET] =
 729                         g_signal_new ("reset",
 730                                       MP_TYPE_PROCESS,
 731                                       G_SIGNAL_RUN_LAST,
 732                                       G_STRUCT_OFFSET (MPProcessClass, reset),
 733                                       NULL, NULL,
 734                                       g_cclosure_marshal_VOID__VOID,
 735                                       G_TYPE_NONE, 0);
 736
 737                 initialized = TRUE;
 738         }
 739 }
 740
 741 static void
 742 mp_process_init (MPProcess *process)
 743 {
 744         process->status = MP_PROCESS_INIT;
 745         process->pid = 0;
 746         process->clone_of = NULL;
 747
 748         process->bytes_used = 0;
 749         process->n_allocations = 0;
 750         process->block_table = NULL;
 751         process->stack_stash = NULL;
 752
 753         process->program_name = NULL;
 754         process->input_channel = NULL;
 755
 756         process->seqno = 0;
 757
 758         process->command_queue = NULL;
 759
 760         process->follow_fork = FALSE;
 761         process->follow_exec = FALSE;
 762
 763         g_object_ref (G_OBJECT (process));
 764 }
 765
 766 static void
 767 mp_process_finalize (GObject *object)
 768 {
 769         MPProcess *process = MP_PROCESS (object);
 770
 771         process_reinit (process);
 772
 773         g_free (process->program_name);
 774 }
 775
 776
 777 MPProcess *
 778 process_new (MPServer *server)
 779 {
 780         MPProcess *process;
 781
 782         process = g_object_new (MP_TYPE_PROCESS, NULL);
 783
 784         process->server = server;
 785
 786         return process;
 787 }
 788
 789 void
 790 process_set_follow_fork (MPProcess *process,
 791                          gboolean   follow_fork)
 792 {
 793         process->follow_fork = follow_fork;
 794 }
 795
 796 void
 797 process_set_follow_exec (MPProcess *process,
 798                          gboolean   follow_exec)
 799 {
 800         process->follow_exec = follow_exec;
 801 }
 802
 803 void
 804 process_run (MPProcess *process, const char *path, char **args)
 805 {
 806         process->program_name = g_strdup (path);
 807         read_inode (path);
 808
 809         process->pid = mp_server_instrument (process->server, path, args);
 810         mp_server_add_process (process->server, process);
 811
 812         process_set_status (process, MP_PROCESS_STARTING);
 813
 814         process_start_input (process);
 815 }
 816
 817 GList *
 818 process_get_clones (MPProcess *process)
 819 {
 820         return mp_server_get_process_clones (process->server, process);
 821 }
 822
 823 void
 824 process_set_status (MPProcess *process, MPProcessStatus status)
 825 {
 826         if (process->status != status) {
 827                 process->status = status;
 828                 g_signal_emit_by_name (process, "status_changed", NULL);
 829         }
 830 }
 831
 832 char *
 833 process_get_status_text (MPProcess *process)
 834 {
 835         char *status = "";
 836
 837         switch (process->status) {
 838         case MP_PROCESS_INIT:
 839                 status = _("Initial");
 840                 break;
 841         case MP_PROCESS_STARTING:
 842                 status = _("Starting");
 843                 break;
 844         case MP_PROCESS_RUNNING:
 845                 status = _("Running");
 846                 break;
 847         case MP_PROCESS_EXITING:
 848                 status = _("Exiting");
 849                 break;
 850         case MP_PROCESS_DEFUNCT:
 851                 status = _("Defunct");
 852                 break;
 853         case MP_PROCESS_DETACHED:
 854                 status = _("Defunct");
 855                 break;
 856         }
 857
 858         return g_strdup (status);
 859 }
 860
 861 char *
 862 process_get_cmdline (MPProcess *process)
 863 {
 864         char *fname;
 865         char *result;
 866         char *tmp = NULL;
 867         size_t n = 0;
 868         FILE *in = NULL;
 869
 870         if (process->status == MP_PROCESS_DEFUNCT)
 871                 return g_strdup ("");
 872
 873         fname = g_strdup_printf ("/proc/%d/cmdline", process->pid);
 874         in = fopen (fname, "r");
 875         if (!in) {
 876                 g_warning ("Can't open %s\n", fname);
 877                 return g_strdup ("");
 878         }
 879         g_free (fname);
 880
 881         if (getline (&tmp, &n, in) == -1)
 882                 result = g_strdup ("");
 883         else {
 884                 result = g_strdup (tmp);
 885                 free (tmp);
 886         }
 887
 888         fclose (in);
 889
 890         return result;
 891 }
 892
 893 void
 894 process_detach (MPProcess *process)
 895 {
 896         int ret;
 897
 898         if (process->status != MP_PROCESS_DEFUNCT) {
 899                 int fd = g_io_channel_unix_get_fd (process->input_channel);
 900
 901                 if (process->status == MP_PROCESS_EXITING) {
 902                         char response = 0;
 903                         ret = write (fd, &response, 1);
 904                 } else {
 905                         g_io_channel_shutdown (process->input_channel, TRUE, NULL);
 906                         process_set_status (process, MP_PROCESS_DETACHED);
 907                 }
 908         }
 909 }
 910
 911 void
 912 process_kill (MPProcess *process)
 913 {
 914         if (process->status == MP_PROCESS_EXITING) {
 915                 process_detach (process);
 916         } else if (process->status != MP_PROCESS_DEFUNCT &&
 917                    process->status != MP_PROCESS_INIT) {
 918                 kill (process->pid, SIGTERM);
 919         }
 920 }
 921
 922 typedef struct {
 923         MPProcessBlockForeachFunc foreach_func;
 924         gpointer data;
 925 } BlockForeachInfo;
 926
 927 static void
 928 block_table_foreach_func (gpointer key,
 929                           gpointer value,
 930                           gpointer data)
 931 {
 932         BlockForeachInfo *info = data;
 933
 934         info->foreach_func (value, info->data);
 935 }
 936
 937 void
 938 process_block_foreach (MPProcess                 *process,
 939                        MPProcessBlockForeachFunc  foreach_func,
 940                        gpointer                   data)
 941 {
 942         GHashTable *block_table = get_block_table (process);
 943         BlockForeachInfo info;
 944
 945         info.foreach_func = foreach_func;
 946         info.data = data;
 947
 948         g_hash_table_foreach (block_table, block_table_foreach_func, &info);
 949 }
 950
 951 gboolean
 952 symbol_equal (gconstpointer s1, gconstpointer s2)
 953 {
 954         return s1 == s2;
 955 }
 956
 957 guint
 958 symbol_hash  (gconstpointer s)
 959 {
 960         const char *symbol = s;
 961
 962         return g_str_hash (symbol);
 963 }
 964
 965 char *
 966 symbol_copy  (const char *orig)
 967 {
 968         if (!orig)
 969                 return NULL;
 970
 971         return (char *) orig;
 972 }
 973
 974 void
 975 symbol_free  (char *symbol)
 976 {
 977         if (!symbol)
 978                 return;
 979 }
 980