Lines Matching defs:arg

106 		     struct tep_event *event, struct tep_print_arg *arg);
862 static void free_arg(struct tep_print_arg *arg)
866 if (!arg)
869 switch (arg->type) {
871 free(arg->atom.atom);
874 free(arg->field.name);
877 free_arg(arg->flags.field);
878 free(arg->flags.delim);
879 free_flag_sym(arg->flags.flags);
882 free_arg(arg->symbol.field);
883 free_flag_sym(arg->symbol.symbols);
887 free_arg(arg->hex.field);
888 free_arg(arg->hex.size);
891 free_arg(arg->int_array.field);
892 free_arg(arg->int_array.count);
893 free_arg(arg->int_array.el_size);
896 free(arg->typecast.type);
897 free_arg(arg->typecast.item);
901 free(arg->string.string);
904 free(arg->bitmask.bitmask);
908 free(arg->dynarray.index);
911 free(arg->op.op);
912 free_arg(arg->op.left);
913 free_arg(arg->op.right);
916 while (arg->func.args) {
917 farg = arg->func.args;
918 arg->func.args = farg->next;
928 free(arg);
1752 process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
1756 process_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1764 return process_arg_token(event, arg, tok, type);
1768 process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok);
1775 process_field_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1779 type = process_arg(event, arg, tok);
1782 type = process_op(event, arg, tok);
1791 struct tep_print_arg *arg, *left, *right;
1795 arg = alloc_arg();
1799 if (!arg || !left || !right) {
1801 /* arg will be freed at out_free */
1807 arg->type = TEP_PRINT_OP;
1808 arg->op.left = left;
1809 arg->op.right = right;
1827 arg->op.op = token;
1831 top->op.right = arg;
1840 free_arg(arg);
1847 struct tep_print_arg *arg;
1851 arg = alloc_arg();
1852 if (!arg) {
1860 type = process_arg(event, arg, &token);
1864 top->op.right = arg;
1874 free_arg(arg);
1933 static int set_op_prio(struct tep_print_arg *arg)
1937 if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1938 arg->op.prio = 0;
1940 arg->op.prio = get_op_prio(arg->op.op);
1942 return arg->op.prio;
1947 process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1956 if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1980 arg->op.left = left;
1986 arg->op.right = right;
1998 /* copy the top arg to the left */
1999 *left = *arg;
2001 arg->type = TEP_PRINT_OP;
2002 arg->op.op = token;
2003 arg->op.left = left;
2004 arg->op.prio = 0;
2006 /* it will set arg->op.right */
2007 type = process_cond(event, arg, tok);
2032 /* copy the top arg to the left */
2033 *left = *arg;
2035 arg->type = TEP_PRINT_OP;
2036 arg->op.op = token;
2037 arg->op.left = left;
2038 arg->op.right = NULL;
2040 if (set_op_prio(arg) == -1) {
2042 /* arg->op.op (= token) will be freed at out_free */
2043 arg->op.op = NULL;
2051 if ((strcmp(arg->op.op, "*") == 0) &&
2063 free(arg->op.op);
2064 *arg = *left;
2083 get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2087 arg->op.right = right->op.left;
2089 tmp = *arg;
2090 *arg = *right;
2093 arg->op.left = right;
2095 arg->op.right = right;
2104 *left = *arg;
2106 arg->type = TEP_PRINT_OP;
2107 arg->op.op = token;
2108 arg->op.left = left;
2110 arg->op.prio = 0;
2112 /* it will set arg->op.right */
2113 type = process_array(event, arg, tok);
2118 /* the arg is now the left side */
2128 if (prio > arg->op.prio)
2129 return process_op(event, arg, tok);
2145 process_entry(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2159 arg->type = TEP_PRINT_FIELD;
2160 arg->field.name = field;
2163 arg->field.field = tep_find_any_field(event, arg->field.name);
2164 arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2167 arg->field.field = tep_find_any_field(event, arg->field.name);
2168 arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2216 static char *arg_eval (struct tep_print_arg *arg);
2253 /* Try to figure out the arg size*/
2313 eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2315 if (arg->type != TEP_PRINT_TYPE) {
2320 return eval_type_str(val, arg->typecast.type, pointer);
2323 static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2328 switch (arg->type) {
2330 *val = strtoll(arg->atom.atom, NULL, 0);
2333 ret = arg_num_eval(arg->typecast.item, val);
2336 *val = eval_type(*val, arg, 0);
2339 switch (arg->op.op[0]) {
2341 ret = arg_num_eval(arg->op.left, &left);
2344 ret = arg_num_eval(arg->op.right, &right);
2347 if (arg->op.op[1])
2353 ret = arg_num_eval(arg->op.left, &left);
2356 ret = arg_num_eval(arg->op.right, &right);
2359 if (arg->op.op[1])
2365 ret = arg_num_eval(arg->op.left, &left);
2368 ret = arg_num_eval(arg->op.right, &right);
2371 switch (arg->op.op[1]) {
2382 do_warning("unknown op '%s'", arg->op.op);
2387 ret = arg_num_eval(arg->op.left, &left);
2390 ret = arg_num_eval(arg->op.right, &right);
2393 switch (arg->op.op[1]) {
2404 do_warning("unknown op '%s'", arg->op.op);
2409 ret = arg_num_eval(arg->op.left, &left);
2412 ret = arg_num_eval(arg->op.right, &right);
2416 if (arg->op.op[1] != '=') {
2417 do_warning("unknown op '%s'", arg->op.op);
2423 ret = arg_num_eval(arg->op.left, &left);
2426 ret = arg_num_eval(arg->op.right, &right);
2430 switch (arg->op.op[1]) {
2435 do_warning("unknown op '%s'", arg->op.op);
2441 if (arg->op.left->type == TEP_PRINT_NULL)
2444 ret = arg_num_eval(arg->op.left, &left);
2447 ret = arg_num_eval(arg->op.right, &right);
2453 if (arg->op.left->type == TEP_PRINT_NULL)
2456 ret = arg_num_eval(arg->op.left, &left);
2459 ret = arg_num_eval(arg->op.right, &right);
2465 ret = arg_num_eval(arg->op.right, &right);
2471 do_warning("unknown op '%s'", arg->op.op);
2482 do_warning("invalid eval type %d", arg->type);
2489 static char *arg_eval (struct tep_print_arg *arg)
2494 switch (arg->type) {
2496 return arg->atom.atom;
2498 return arg_eval(arg->typecast.item);
2500 if (!arg_num_eval(arg, &val))
2511 do_warning("invalid eval type %d", arg->type);
2522 struct tep_print_arg *arg = NULL;
2533 arg = alloc_arg();
2534 if (!arg)
2538 type = process_arg(event, arg, &token);
2541 type = process_op(event, arg, &token);
2553 value = arg_eval(arg);
2560 free_arg(arg);
2561 arg = alloc_arg();
2562 if (!arg)
2566 type = process_arg(event, arg, &token);
2570 value = arg_eval(arg);
2576 free_arg(arg);
2577 arg = NULL;
2592 free_arg(arg);
2600 process_flags(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2606 memset(arg, 0, sizeof(*arg));
2607 arg->type = TEP_PRINT_FLAGS;
2625 arg->flags.field = field;
2629 arg->flags.delim = token;
2636 type = process_fields(event, &arg->flags.flags, &token);
2653 process_symbols(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2659 memset(arg, 0, sizeof(*arg));
2660 arg->type = TEP_PRINT_SYMBOL;
2673 arg->symbol.field = field;
2675 type = process_fields(event, &arg->symbol.symbols, &token);
2692 process_hex_common(struct tep_event *event, struct tep_print_arg *arg,
2695 memset(arg, 0, sizeof(*arg));
2696 arg->type = type;
2698 if (alloc_and_process_delim(event, ",", &arg->hex.field))
2701 if (alloc_and_process_delim(event, ")", &arg->hex.size))
2707 free_arg(arg->hex.field);
2708 arg->hex.field = NULL;
2715 process_hex(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2717 return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2721 process_hex_str(struct tep_event *event, struct tep_print_arg *arg,
2724 return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2728 process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2730 memset(arg, 0, sizeof(*arg));
2731 arg->type = TEP_PRINT_INT_ARRAY;
2733 if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2736 if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2739 if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2745 free_arg(arg->int_array.count);
2746 arg->int_array.count = NULL;
2748 free_arg(arg->int_array.field);
2749 arg->int_array.field = NULL;
2756 process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2762 memset(arg, 0, sizeof(*arg));
2763 arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2780 arg->dynarray.field = field;
2781 arg->dynarray.index = 0;
2793 arg = alloc_arg();
2794 if (!arg) {
2800 type = process_arg(event, arg, &token);
2812 free_arg(arg);
2820 process_dynamic_array_len(struct tep_event *event, struct tep_print_arg *arg,
2830 arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2837 arg->dynarray.field = field;
2838 arg->dynarray.index = 0;
2857 process_paren(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2863 type = process_arg(event, arg, &token);
2869 type = process_op(event, arg, &token);
2890 if (arg->type != TEP_PRINT_ATOM) {
2902 arg->type = TEP_PRINT_TYPE;
2903 arg->typecast.type = arg->atom.atom;
2904 arg->typecast.item = item_arg;
2920 process_str(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2929 arg->type = TEP_PRINT_STRING;
2930 arg->string.string = token;
2931 arg->string.offset = -1;
2949 process_bitmask(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2958 arg->type = TEP_PRINT_BITMASK;
2959 arg->bitmask.bitmask = token;
2960 arg->bitmask.offset = -1;
3011 struct tep_print_arg *arg, char **tok)
3019 arg->type = TEP_PRINT_FUNC;
3020 arg->func.func = func;
3024 next_arg = &(arg->func.args);
3068 process_builtin_expect(struct tep_event *event, struct tep_print_arg *arg, char **tok)
3074 type = process_arg(event, arg, &token);
3099 process_function(struct tep_event *event, struct tep_print_arg *arg,
3107 return process_flags(event, arg, tok);
3112 return process_symbols(event, arg, tok);
3116 return process_hex(event, arg, tok);
3120 return process_hex_str(event, arg, tok);
3124 return process_int_array(event, arg, tok);
3128 return process_str(event, arg, tok);
3132 return process_bitmask(event, arg, tok);
3136 return process_dynamic_array(event, arg, tok);
3140 return process_dynamic_array_len(event, arg, tok);
3144 return process_builtin_expect(event, arg, tok);
3150 return process_func_handler(event, func, arg, tok);
3159 process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
3171 type = process_entry(event, arg, &token);
3186 type = process_function(event, arg, atom, &token);
3204 arg->type = TEP_PRINT_ATOM;
3205 arg->atom.atom = atom;
3210 arg->type = TEP_PRINT_ATOM;
3211 arg->atom.atom = token;
3217 type = process_paren(event, arg, &token);
3222 arg->type = TEP_PRINT_OP;
3223 arg->op.op = token;
3224 arg->op.left = NULL;
3225 type = process_op(event, arg, &token);
3229 arg->op.op = NULL;
3247 struct tep_print_arg *arg;
3257 arg = alloc_arg();
3258 if (!arg) {
3264 type = process_arg(event, arg, &token);
3268 free_arg(arg);
3272 *list = arg;
3276 type = process_op(event, arg, &token);
3280 free_arg(arg);
3283 list = &arg->next;
3289 *list = arg;
3290 list = &arg->next;
3324 /* ok to have no arg */
3633 eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg *arg)
3643 switch (arg->type) {
3648 return strtoull(arg->atom.atom, NULL, 0);
3650 if (!arg->field.field) {
3651 arg->field.field = tep_find_any_field(event, arg->field.name);
3652 if (!arg->field.field)
3657 val = tep_read_number(tep, data + arg->field.field->offset,
3658 arg->field.field->size);
3667 val = eval_num_arg(data, size, event, arg->typecast.item);
3668 return eval_type(val, arg, 0);
3676 val = process_defined_func(&s, data, size, event, arg);
3681 if (strcmp(arg->op.op, "[") == 0) {
3684 * to read the arg as is.
3686 right = eval_num_arg(data, size, event, arg->op.right);
3689 larg = arg->op.left;
3719 arg = larg;
3735 } else if (strcmp(arg->op.op, "?") == 0) {
3736 left = eval_num_arg(data, size, event, arg->op.left);
3737 arg = arg->op.right;
3739 val = eval_num_arg(data, size, event, arg->op.left);
3741 val = eval_num_arg(data, size, event, arg->op.right);
3745 left = eval_num_arg(data, size, event, arg->op.left);
3746 right = eval_num_arg(data, size, event, arg->op.right);
3747 switch (arg->op.op[0]) {
3749 switch (arg->op.op[1]) {
3764 if (arg->op.op[1])
3770 if (arg->op.op[1])
3776 switch (arg->op.op[1]) {
3791 switch (arg->op.op[1]) {
3806 if (arg->op.op[1] != '=')
3832 data + arg->dynarray.field->offset,
3833 arg->dynarray.field->size);
3844 data + arg->dynarray.field->offset,
3845 arg->dynarray.field->size);
3860 do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3865 __func__, arg->field.name);
3974 int len_arg, struct tep_print_arg *arg)
3987 switch (arg->type) {
3992 print_str_to_seq(s, format, len_arg, arg->atom.atom);
3995 field = arg->field.field;
3997 field = tep_find_any_field(event, arg->field.name);
3999 str = arg->field.name;
4002 arg->field.field = field;
4052 val = eval_num_arg(data, size, event, arg->flags.field);
4054 for (flag = arg->flags.flags; flag; flag = flag->next) {
4061 if (print && arg->flags.delim)
4062 trace_seq_puts(s, arg->flags.delim);
4069 if (print && arg->flags.delim)
4070 trace_seq_puts(s, arg->flags.delim);
4075 val = eval_num_arg(data, size, event, arg->symbol.field);
4076 for (flag = arg->symbol.symbols; flag; flag = flag->next) {
4088 if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4091 data + arg->hex.field->dynarray.field->offset,
4092 arg->hex.field->dynarray.field->size);
4095 field = arg->hex.field->field.field;
4097 str = arg->hex.field->field.name;
4101 arg->hex.field->field.field = field;
4105 len = eval_num_arg(data, size, event, arg->hex.size);
4107 if (i && arg->type == TEP_PRINT_HEX)
4117 if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4120 arg->int_array.field->dynarray.field;
4126 field = arg->int_array.field->field.field;
4128 str = arg->int_array.field->field.name;
4132 arg->int_array.field->field.field = field;
4136 len = eval_num_arg(data, size, event, arg->int_array.count);
4138 arg->int_array.el_size);
4166 if (arg->string.offset == -1) {
4169 f = tep_find_any_field(event, arg->string.string);
4170 arg->string.offset = f->offset;
4172 str_offset = data2host4(tep, *(unsigned int *)(data + arg->string.offset));
4178 print_str_to_seq(s, format, len_arg, arg->string.string);
4184 if (arg->bitmask.offset == -1) {
4187 f = tep_find_any_field(event, arg->bitmask.bitmask);
4188 arg->bitmask.offset = f->offset;
4190 bitmask_offset = data2host4(tep, *(unsigned int *)(data + arg->bitmask.offset));
4201 if (arg->op.op[0] != '?')
4203 val = eval_num_arg(data, size, event, arg->op.left);
4206 format, len_arg, arg->op.right->op.left);
4209 format, len_arg, arg->op.right->op.right);
4212 process_defined_func(s, data, size, event, arg);
4223 __func__, arg->field.name);
4228 struct tep_event *event, struct tep_print_arg *arg)
4230 struct tep_function_handler *func_handle = arg->func.func;
4247 farg = arg->func.args;
4327 struct tep_print_arg *args, *arg, **next;
4354 * The first arg is the IP pointer.
4362 arg = args;
4363 arg->next = NULL;
4364 next = &arg->next;
4366 arg->type = TEP_PRINT_ATOM;
4368 if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4460 arg = alloc_arg();
4461 if (!arg) {
4466 arg->next = NULL;
4467 arg->type = TEP_PRINT_ATOM;
4468 if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4469 free(arg);
4472 *next = arg;
4473 next = &arg->next;
4475 * The '*' case means that an arg is used as the length.
4484 arg = alloc_arg();
4485 if (!arg) {
4490 arg->next = NULL;
4491 arg->type = TEP_PRINT_BSTRING;
4492 arg->string.string = strdup(bptr);
4493 if (!arg->string.string)
4496 *next = arg;
4497 next = &arg->next;
4549 struct tep_print_arg *arg)
4556 if (arg->type == TEP_PRINT_FUNC) {
4557 process_defined_func(s, data, size, event, arg);
4561 if (arg->type != TEP_PRINT_FIELD) {
4563 arg->type);
4578 if (!arg->field.field) {
4579 arg->field.field =
4580 tep_find_any_field(event, arg->field.name);
4581 if (!arg->field.field) {
4583 __func__, arg->field.name);
4587 if (arg->field.field->size != 6) {
4592 buf = data + arg->field.field->offset;
4756 struct tep_print_arg *arg)
4764 if (arg->type == TEP_PRINT_FUNC) {
4765 process_defined_func(s, data, size, event, arg);
4769 if (arg->type != TEP_PRINT_FIELD) {
4770 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4774 if (!arg->field.field) {
4775 arg->field.field =
4776 tep_find_any_field(event, arg->field.name);
4777 if (!arg->field.field) {
4779 __func__, arg->field.name);
4784 buf = data + arg->field.field->offset;
4786 if (arg->field.field->size != 4) {
4798 struct tep_print_arg *arg)
4811 if (arg->type == TEP_PRINT_FUNC) {
4812 process_defined_func(s, data, size, event, arg);
4816 if (arg->type != TEP_PRINT_FIELD) {
4817 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4821 if (!arg->field.field) {
4822 arg->field.field =
4823 tep_find_any_field(event, arg->field.name);
4824 if (!arg->field.field) {
4826 __func__, arg->field.name);
4831 buf = data + arg->field.field->offset;
4833 if (arg->field.field->size != 16) {
4848 struct tep_print_arg *arg)
4874 if (arg->type == TEP_PRINT_FUNC) {
4875 process_defined_func(s, data, size, event, arg);
4879 if (arg->type != TEP_PRINT_FIELD) {
4880 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4884 if (!arg->field.field) {
4885 arg->field.field =
4886 tep_find_any_field(event, arg->field.name);
4887 if (!arg->field.field) {
4889 __func__, arg->field.name);
4894 sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4899 if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4912 if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4935 struct tep_print_arg *arg)
4945 rc += print_ipv4_arg(s, ptr + 1, i, data, size, event, arg);
4948 rc += print_ipv6_arg(s, ptr + 1, i, data, size, event, arg);
4951 rc += print_ipsa_arg(s, ptr + 1, i, data, size, event, arg);
4965 struct tep_print_arg *arg)
4989 if (arg->type == TEP_PRINT_FUNC) {
4990 process_defined_func(s, data, size, event, arg);
4994 if (arg->type != TEP_PRINT_FIELD) {
4995 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4999 if (!arg->field.field) {
5000 arg->field.field =
5001 tep_find_any_field(event, arg->field.name);
5002 if (!arg->field.field) {
5004 __func__, arg->field.name);
5009 if (arg->field.field->size != 16) {
5014 buf = data + arg->field.field->offset;
5033 struct tep_print_arg *arg, int print_len)
5058 if (arg->type == TEP_PRINT_FUNC) {
5059 process_defined_func(s, data, size, event, arg);
5063 if (arg->type != TEP_PRINT_DYNAMIC_ARRAY) {
5064 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
5069 data + arg->dynarray.field->offset,
5070 arg->dynarray.field->size);
5177 struct tep_print_arg *arg)
5182 val = eval_num_arg(data, size, event, arg);
5200 struct tep_event *event, struct tep_print_arg *arg)
5205 if (arg->type == TEP_PRINT_BSTRING) {
5206 trace_seq_puts(s, arg->string.string);
5222 ret += print_function(s, format, data, size, event, arg);
5226 ret += print_mac_arg(s, format, data, size, event, arg);
5230 ret += print_ip_arg(s, format, data, size, event, arg);
5233 ret += print_uuid_arg(s, format, data, size, event, arg);
5236 ret += print_raw_buff_arg(s, format, data, size, event, arg, plen);
5240 val = eval_num_arg(data, size, event, arg);
5251 struct tep_event *event, struct tep_print_arg *arg)
5255 val = eval_num_arg(data, size, event, arg);
5298 struct tep_event *event, struct tep_print_arg *arg)
5305 format, plen, arg);
5409 static void free_parse_args(struct tep_print_parse *arg)
5413 while (arg) {
5414 del = arg;
5415 arg = del->next;
5423 struct tep_print_arg *arg,
5436 parg->arg = arg;
5451 const char *format, struct tep_print_arg **arg)
5485 if (!*arg) {
5495 len_arg = *arg;
5496 *arg = (*arg)->next;
5499 if (!*arg) {
5521 PRINT_FMT_ARG_POINTER, *arg, len_arg, ls);
5522 *arg = (*arg)->next;
5531 if (!*arg) {
5563 PRINT_FMT_ARG_DIGIT, *arg, len_arg, ls);
5564 *arg = (*arg)->next;
5568 if (!*arg) {
5588 PRINT_FMT_ARG_STRING, *arg, len_arg, 0);
5589 *arg = (*arg)->next;
5654 parse_args(struct tep_event *event, const char *format, struct tep_print_arg *arg)
5666 ret = parse_arg_format(parse, event, format, &arg);
5693 size, parse->ls, event, parse->arg);
5698 data, size, event, parse->arg);
5703 data, size, event, parse->arg);
6081 const char *arg, struct print_event_type *type)
6086 if (strncmp(arg, TEP_PRINT_LATENCY, strlen(TEP_PRINT_LATENCY)) == 0) {
6088 } else if (strncmp(arg, TEP_PRINT_COMM, strlen(TEP_PRINT_COMM)) == 0) {
6092 } else if (strncmp(arg, TEP_PRINT_INFO_RAW, strlen(TEP_PRINT_INFO_RAW)) == 0) {
6094 } else if (strncmp(arg, TEP_PRINT_INFO, strlen(TEP_PRINT_INFO)) == 0) {
6096 } else if (strncmp(arg, TEP_PRINT_NAME, strlen(TEP_PRINT_NAME)) == 0) {
6099 trace_seq_printf(s, "[UNKNOWN TEP TYPE %s]", arg);
6106 int arg, struct print_event_type *type)
6110 switch (arg) {
6813 struct tep_print_arg *arg, **list;
6818 arg = alloc_arg();
6819 if (!arg) {
6823 arg->type = TEP_PRINT_FIELD;
6824 arg->field.name = strdup(field->name);
6825 if (!arg->field.name) {
6827 free_arg(arg);
6830 arg->field.field = field;
6831 *list = arg;
6832 list = &arg->next;