Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of ltrace. |
Petr Machata | 6bcc092 | 2014-01-09 23:50:07 +0100 | [diff] [blame] | 3 | * Copyright (C) 2010,2011,2012,2013,2014 Petr Machata, Red Hat Inc. |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 4 | * Copyright (C) 2010 Joe Damato |
| 5 | * Copyright (C) 1998,2001,2008,2009 Juan Cespedes |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU General Public License as |
| 9 | * published by the Free Software Foundation; either version 2 of the |
| 10 | * License, or (at your option) any later version. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * 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., 51 Franklin St, Fifth Floor, Boston, MA |
| 20 | * 02110-1301 USA |
| 21 | */ |
| 22 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 23 | #ifndef _PROC_H_ |
| 24 | #define _PROC_H_ |
| 25 | |
Petr Machata | 8a568dd | 2012-05-18 14:12:27 +0200 | [diff] [blame] | 26 | #include "config.h" |
| 27 | |
Andrey Zonov | d2c5dfd | 2012-08-05 00:16:55 +0400 | [diff] [blame] | 28 | #include <sys/time.h> |
Petr Machata | 653085a | 2013-01-15 17:40:40 +0100 | [diff] [blame] | 29 | #include <stdint.h> |
Andrey Zonov | d2c5dfd | 2012-08-05 00:16:55 +0400 | [diff] [blame] | 30 | |
Mark Wielaard | dfefa9f | 2014-01-07 21:00:44 +0100 | [diff] [blame] | 31 | #if defined(HAVE_LIBDW) |
| 32 | # include <elfutils/libdwfl.h> |
| 33 | #endif |
| 34 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 35 | #if defined(HAVE_LIBUNWIND) |
| 36 | # include <libunwind.h> |
Luca Clementi | af452c6 | 2014-01-03 22:05:03 -0800 | [diff] [blame] | 37 | # include <libunwind-ptrace.h> |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 38 | #endif /* defined(HAVE_LIBUNWIND) */ |
| 39 | |
| 40 | #include "ltrace.h" |
| 41 | #include "dict.h" |
Petr Machata | 744f255 | 2012-04-15 04:33:18 +0200 | [diff] [blame] | 42 | #include "sysdep.h" |
Petr Machata | a24021c | 2012-09-25 14:46:44 +0200 | [diff] [blame] | 43 | #include "callback.h" |
Petr Machata | 6d8aa0b | 2012-10-31 03:27:36 +0100 | [diff] [blame] | 44 | #include "forward.h" |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 45 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 46 | struct event_handler { |
| 47 | /* Event handler that overrides the default one. Should |
| 48 | * return NULL if the event was handled, otherwise the |
| 49 | * returned event is passed to the default handler. */ |
| 50 | Event *(*on_event)(struct event_handler *self, Event *event); |
| 51 | |
| 52 | /* Called when the event handler removal is requested. */ |
| 53 | void (*destroy)(struct event_handler *self); |
| 54 | }; |
| 55 | |
| 56 | enum process_state { |
| 57 | STATE_ATTACHED = 0, |
| 58 | STATE_BEING_CREATED, |
| 59 | STATE_IGNORED /* ignore this process (it's a fork and no -f was used) */ |
| 60 | }; |
| 61 | |
Petr Machata | f6ec08a | 2012-01-06 16:58:54 +0100 | [diff] [blame] | 62 | struct output_state { |
| 63 | size_t params_left; |
| 64 | int need_delim; |
| 65 | }; |
| 66 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 67 | struct callstack_element { |
| 68 | union { |
| 69 | int syscall; |
| 70 | struct library_symbol * libfunc; |
| 71 | } c_un; |
| 72 | int is_syscall; |
Petr Machata | 4dcc389 | 2013-01-30 23:11:35 +0100 | [diff] [blame] | 73 | arch_addr_t return_addr; |
Petr Machata | 8a730f3 | 2013-11-21 20:43:51 +0100 | [diff] [blame] | 74 | struct timeval enter_time; |
Petr Machata | f6ec08a | 2012-01-06 16:58:54 +0100 | [diff] [blame] | 75 | struct fetch_context *fetch_context; |
Petr Machata | 94078ec | 2012-01-05 18:07:02 +0100 | [diff] [blame] | 76 | struct value_dict *arguments; |
Petr Machata | f6ec08a | 2012-01-06 16:58:54 +0100 | [diff] [blame] | 77 | struct output_state out; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 78 | }; |
| 79 | |
| 80 | /* XXX We should get rid of this. */ |
| 81 | #define MAX_CALLDEPTH 64 |
| 82 | |
| 83 | /* XXX We would rather have this all organized a little differently, |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 84 | * have struct process for the whole group and struct task (or struct |
| 85 | * lwp, struct thread) for what's there for per-thread stuff. But for |
| 86 | * now this is the less invasive way of structuring it. */ |
| 87 | struct process { |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 88 | enum process_state state; |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 89 | struct process *parent; /* needed by STATE_BEING_CREATED */ |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 90 | char * filename; |
| 91 | pid_t pid; |
| 92 | |
| 93 | /* Dictionary of breakpoints (which is a mapping |
| 94 | * address->breakpoint). This is NULL for non-leader |
Petr Machata | d7e4ca8 | 2012-11-28 03:38:47 +0100 | [diff] [blame] | 95 | * processes. */ |
| 96 | struct dict *breakpoints; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 97 | |
| 98 | int mask_32bit; /* 1 if 64-bit ltrace is tracing 32-bit process */ |
| 99 | unsigned int personality; |
| 100 | int tracesysgood; /* signal indicating a PTRACE_SYSCALL trap */ |
| 101 | |
Petr Machata | ba1664b | 2012-04-28 14:59:05 +0200 | [diff] [blame] | 102 | size_t callstack_depth; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 103 | struct callstack_element callstack[MAX_CALLDEPTH]; |
Petr Machata | 76dd929 | 2012-04-03 13:02:06 +0200 | [diff] [blame] | 104 | |
| 105 | /* Linked list of libraries in backwards order of mapping. |
| 106 | * The last element is the executed binary itself. */ |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 107 | struct library *libraries; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 108 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 109 | /* Arch-dependent: */ |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 110 | void * instruction_pointer; |
| 111 | void * stack_pointer; /* To get return addr, args... */ |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 112 | void * arch_ptr; |
Petr Machata | 4d4e1b8 | 2012-05-30 11:08:39 -0400 | [diff] [blame] | 113 | |
| 114 | /* XXX We would like to replace this with a pointer to ABI |
| 115 | * object that would provide the relevant services, instead of |
| 116 | * checking the necessary flags in the back end ad |
| 117 | * nauseam. */ |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 118 | short e_machine; |
Petr Machata | 4d4e1b8 | 2012-05-30 11:08:39 -0400 | [diff] [blame] | 119 | char e_class; |
| 120 | |
Mark Wielaard | dfefa9f | 2014-01-07 21:00:44 +0100 | [diff] [blame] | 121 | #if defined(HAVE_LIBDW) |
| 122 | /* Unwind info for leader, NULL for non-leader procs. */ |
| 123 | Dwfl *dwfl; |
| 124 | #endif /* defined(HAVE_LIBDW) */ |
| 125 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 126 | #if defined(HAVE_LIBUNWIND) |
| 127 | /* libunwind address space */ |
| 128 | unw_addr_space_t unwind_as; |
| 129 | void *unwind_priv; |
| 130 | #endif /* defined(HAVE_LIBUNWIND) */ |
| 131 | |
| 132 | /* Set in leader. */ |
| 133 | struct event_handler *event_handler; |
| 134 | |
| 135 | /** |
| 136 | * Process chaining. |
| 137 | **/ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 138 | struct process *next; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 139 | |
| 140 | /* LEADER points to the leader thread of the POSIX.1 process. |
| 141 | If X->LEADER == X, then X is the leader thread and the |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 142 | process structures chained by NEXT represent other threads, |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 143 | up until, but not including, the next leader thread. |
| 144 | LEADER may be NULL after the leader has already exited. In |
| 145 | that case this process is waiting to be collected. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 146 | struct process *leader; |
Petr Machata | 744f255 | 2012-04-15 04:33:18 +0200 | [diff] [blame] | 147 | |
Petr Machata | 0f6e6d9 | 2012-10-26 23:42:17 +0200 | [diff] [blame] | 148 | struct os_process_data os; |
Petr Machata | 744f255 | 2012-04-15 04:33:18 +0200 | [diff] [blame] | 149 | struct arch_process_data arch; |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 150 | }; |
| 151 | |
Petr Machata | 75934ad | 2012-04-14 02:28:03 +0200 | [diff] [blame] | 152 | /* Initialize a process given a path to binary FILENAME, with a PID, |
| 153 | * and add the process to an internal chain of traced processes. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 154 | int process_init(struct process *proc, const char *filename, pid_t pid); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 155 | |
Petr Machata | 3d0c91c | 2012-04-14 02:37:38 +0200 | [diff] [blame] | 156 | /* PROC underwent an exec. This is a bit like process_destroy |
| 157 | * followed by process_init, except that some state is kept and the |
| 158 | * process doesn't lose it's place in the list of processes. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 159 | int process_exec(struct process *proc); |
Petr Machata | 3d0c91c | 2012-04-14 02:37:38 +0200 | [diff] [blame] | 160 | |
| 161 | /* Release any memory allocated for PROC (but not PROC itself). Does |
| 162 | * NOT remove PROC from internal chain. |
| 163 | * |
| 164 | * XXX clearly this init/destroy pair is different than others and |
| 165 | * should be fixed. process_init should presumably be separate from |
| 166 | * process_add. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 167 | void process_destroy(struct process *proc); |
Petr Machata | 3d0c91c | 2012-04-14 02:37:38 +0200 | [diff] [blame] | 168 | |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 169 | struct process *open_program(const char *filename, pid_t pid); |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 170 | void open_pid(pid_t pid); |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 171 | struct process *pid2proc(pid_t pid); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 172 | |
| 173 | /* Clone the contents of PROC into the memory referenced by RETP. |
| 174 | * Returns 0 on success or a negative value on failure. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 175 | int process_clone(struct process *retp, struct process *proc, pid_t pid); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 176 | |
Petr Machata | a24021c | 2012-09-25 14:46:44 +0200 | [diff] [blame] | 177 | /* Iterate through the processes that ltrace currently traces. Tasks |
| 178 | * are considered to be processes for the purpose of this iterator. |
| 179 | * See callback.h for notes on iteration interfaces. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 180 | struct process *each_process(struct process *start_after, |
| 181 | enum callback_status (*cb)(struct process *proc, |
| 182 | void *data), |
| 183 | void *data); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 184 | |
Petr Machata | a24021c | 2012-09-25 14:46:44 +0200 | [diff] [blame] | 185 | /* Iterate through list of tasks of given process PROC. See |
| 186 | * callback.h for notes on iteration interfaces. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 187 | struct process *each_task(struct process *proc, struct process *start_after, |
| 188 | enum callback_status (*cb)(struct process *proc, |
| 189 | void *data), |
| 190 | void *data); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 191 | |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 192 | void change_process_leader(struct process *proc, struct process *leader); |
Petr Machata | fd2641c | 2012-04-24 21:33:16 +0200 | [diff] [blame] | 193 | |
Petr Machata | df2c88c | 2013-03-19 17:55:25 +0100 | [diff] [blame] | 194 | /* Prepare those parts of process initialization that need to be done |
| 195 | * after _start is hit (i.e. after dynamic linking was done). */ |
| 196 | void process_hit_start(struct process *proc); |
| 197 | |
Petr Machata | fd2641c | 2012-04-24 21:33:16 +0200 | [diff] [blame] | 198 | /* Remove process from the list of traced processes, drop any events |
| 199 | * in the event queue, destroy it and free memory. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 200 | void remove_process(struct process *proc); |
Petr Machata | fd2641c | 2012-04-24 21:33:16 +0200 | [diff] [blame] | 201 | |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 202 | void install_event_handler(struct process *proc, struct event_handler *handler); |
| 203 | void destroy_event_handler(struct process *proc); |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 204 | |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 205 | /* Add a library LIB to the list of PROC's libraries. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 206 | void proc_add_library(struct process *proc, struct library *lib); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 207 | |
| 208 | /* Remove LIB from list of PROC's libraries. Returns 0 if the library |
| 209 | * was found and unlinked, otherwise returns a negative value. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 210 | int proc_remove_library(struct process *proc, struct library *lib); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 211 | |
Petr Machata | ef2fd27 | 2012-09-28 00:43:01 +0200 | [diff] [blame] | 212 | /* Clear a delayed flag. If a symbol is neither latent, nor delayed, |
| 213 | * a breakpoint is inserted for it. Returns 0 if the activation was |
| 214 | * successful or a negative value if it failed. Note that if a symbol |
| 215 | * is both latent and delayed, this will not enable the corresponding |
| 216 | * breakpoint. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 217 | int proc_activate_delayed_symbol(struct process *proc, |
Petr Machata | ef2fd27 | 2012-09-28 00:43:01 +0200 | [diff] [blame] | 218 | struct library_symbol *libsym); |
| 219 | |
Petr Machata | a24021c | 2012-09-25 14:46:44 +0200 | [diff] [blame] | 220 | /* Iterate through the libraries of PROC. See callback.h for notes on |
| 221 | * iteration interfaces. */ |
Petr Machata | 7ac04ed | 2012-11-23 19:00:41 +0100 | [diff] [blame] | 222 | struct library *proc_each_library(struct process *proc, |
| 223 | struct library *start_after, |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 224 | enum callback_status (*cb)(struct process *p, |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 225 | struct library *l, |
| 226 | void *data), |
| 227 | void *data); |
| 228 | |
Petr Machata | 52dbfb1 | 2012-03-29 16:38:26 +0200 | [diff] [blame] | 229 | /* Insert BP into PROC. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 230 | int proc_add_breakpoint(struct process *proc, struct breakpoint *bp); |
Petr Machata | 52dbfb1 | 2012-03-29 16:38:26 +0200 | [diff] [blame] | 231 | |
Petr Machata | f7fee43 | 2012-04-19 17:00:53 +0200 | [diff] [blame] | 232 | /* Remove BP from PROC. This has no reason to fail in runtime. If it |
| 233 | * does not find BP in PROC, it's hard error guarded by assertion. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 234 | void proc_remove_breakpoint(struct process *proc, struct breakpoint *bp); |
Petr Machata | 2b46cfc | 2012-02-18 11:17:29 +0100 | [diff] [blame] | 235 | |
Petr Machata | a24021c | 2012-09-25 14:46:44 +0200 | [diff] [blame] | 236 | /* Iterate through the breakpoints of PROC. See callback.h for notes |
| 237 | * on iteration interfaces. */ |
Petr Machata | 6bcc092 | 2014-01-09 23:50:07 +0100 | [diff] [blame] | 238 | arch_addr_t *proc_each_breakpoint(struct process *proc, arch_addr_t *start, |
| 239 | enum callback_status (*cb) |
| 240 | (struct process *proc, |
| 241 | struct breakpoint *bp, |
| 242 | void *data), |
| 243 | void *data); |
Petr Machata | d3cc988 | 2012-04-13 21:40:23 +0200 | [diff] [blame] | 244 | |
Edgar E. Iglesias | cc77b0e | 2012-10-09 12:15:20 +0200 | [diff] [blame] | 245 | /* Iterate through the dynamic section at src_addr looking for D_TAG. |
| 246 | * If tag is found, fill it's value in RET and return 0. |
| 247 | * If tag is not found, return a negative value. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 248 | int proc_find_dynamic_entry_addr(struct process *proc, arch_addr_t src_addr, |
Edgar E. Iglesias | cc77b0e | 2012-10-09 12:15:20 +0200 | [diff] [blame] | 249 | int d_tag, arch_addr_t *ret); |
Petr Machata | 165b566 | 2012-10-27 19:23:12 +0200 | [diff] [blame] | 250 | |
| 251 | /* Finds a symbol corresponding to LIBSYM in a process PROC. Returns |
| 252 | * 0 and sets *RETLIB and *RETSYM if the corresponding pointer is |
| 253 | * non-NULL. Returns a negative value when the symbols couldn't be |
| 254 | * found. */ |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 255 | int proc_find_symbol(struct process *proc, struct library_symbol *sym, |
Petr Machata | 165b566 | 2012-10-27 19:23:12 +0200 | [diff] [blame] | 256 | struct library **retlib, struct library_symbol **retsym); |
| 257 | |
Petr Machata | 3240554 | 2012-10-31 03:28:39 +0100 | [diff] [blame] | 258 | /* Iterate through all symbols in all libraries of PROC. See |
| 259 | * callback.h for notes on this interface. */ |
| 260 | struct library_symbol *proc_each_symbol |
Petr Machata | 929bd57 | 2012-12-17 03:20:34 +0100 | [diff] [blame] | 261 | (struct process *proc, struct library_symbol *start_after, |
Petr Machata | 3240554 | 2012-10-31 03:28:39 +0100 | [diff] [blame] | 262 | enum callback_status (*cb)(struct library_symbol *, void *), |
| 263 | void *data); |
| 264 | |
Petr Machata | dc70e76 | 2013-01-23 00:02:26 +0100 | [diff] [blame] | 265 | /* Read 8, 16, 32 or 64-bit quantity located at ADDR in PROC. The |
Petr Machata | 653085a | 2013-01-15 17:40:40 +0100 | [diff] [blame] | 266 | * resulting value is stored in *LP. 0 is returned on success or a |
| 267 | * negative value on failure. This uses umovebytes under the hood |
| 268 | * (see backend.h). */ |
Petr Machata | dc70e76 | 2013-01-23 00:02:26 +0100 | [diff] [blame] | 269 | int proc_read_8(struct process *proc, arch_addr_t addr, uint8_t *lp); |
Petr Machata | 653085a | 2013-01-15 17:40:40 +0100 | [diff] [blame] | 270 | int proc_read_16(struct process *proc, arch_addr_t addr, uint16_t *lp); |
| 271 | int proc_read_32(struct process *proc, arch_addr_t addr, uint32_t *lp); |
| 272 | int proc_read_64(struct process *proc, arch_addr_t addr, uint64_t *lp); |
| 273 | |
Petr Machata | 366c2f4 | 2012-02-09 19:34:36 +0100 | [diff] [blame] | 274 | #endif /* _PROC_H_ */ |