Print this page 
12724 update smatch to 0.6.1-rc1-il-5
Split Close
Expand all
Collapse all
          --- old/usr/src/tools/smatch/src/smatch_mtag.c
          +++ new/usr/src/tools/smatch/src/smatch_mtag.c
↓ open down ↓ 60 lines elided ↑ open up ↑ 
  61   61          MD5_Init(&mdContext);
  62   62          MD5_Update(&mdContext, str, len);
  63   63          MD5_Final(c, &mdContext);
  64   64  
  65   65          *tag &= ~MTAG_ALIAS_BIT;
  66   66          *tag &= ~MTAG_OFFSET_MASK;
  67   67  
  68   68          return *tag;
  69   69  }
  70   70  
  71      -const struct {
  72      -        const char *name;
  73      -        int size_arg;
  74      -} allocator_info[] = {
  75      -        { "kmalloc", 0 },
  76      -        { "kzalloc", 0 },
  77      -        { "devm_kmalloc", 1},
  78      -        { "devm_kzalloc", 1},
  79      -};
       71 +static int save_allocator(void *_allocator, int argc, char **argv, char **azColName)
       72 +{
       73 +        char **allocator = _allocator;
  80   74  
  81      -static bool is_mtag_call(struct expression *expr)
       75 +        if (*allocator) {
       76 +                if (strcmp(*allocator, argv[0]) == 0)
       77 +                        return 0;
       78 +                /* should be impossible */
       79 +                free_string(*allocator);
       80 +                *allocator = alloc_string("unknown");
       81 +                return 0;
       82 +        }
       83 +        *allocator = alloc_string(argv[0]);
       84 +        return 0;
       85 +}
       86 +
       87 +char *get_allocator_info_from_tag(mtag_t tag)
  82   88  {
  83      -        struct expression *arg;
  84      -        int i;
       89 +        char *allocator = NULL;
       90 +
       91 +        run_sql(save_allocator, &allocator,
       92 +                "select value from mtag_info where tag = %lld and type = %d;",
       93 +                tag, ALLOCATOR);
       94 +
       95 +        return allocator;
       96 +}
       97 +
       98 +static char *get_allocator_info(struct expression *expr, struct smatch_state *state)
       99 +{
  85  100          sval_t sval;
  86  101  
      102 +        if (expr->type != EXPR_ASSIGNMENT)
      103 +                return NULL;
      104 +        if (estate_get_single_value(state, &sval))
      105 +                return get_allocator_info_from_tag(sval.value);
      106 +
      107 +        expr = strip_expr(expr->right);
  87  108          if (expr->type != EXPR_CALL ||
  88      -            expr->fn->type != EXPR_SYMBOL ||
  89      -            !expr->fn->symbol)
  90      -                return false;
      109 +            !expr->fn ||
      110 +            expr->fn->type != EXPR_SYMBOL)
      111 +                return NULL;
      112 +        return expr_to_str(expr->fn);
      113 +}
  91  114  
  92      -        for (i = 0; i < ARRAY_SIZE(allocator_info); i++) {
  93      -                if (strcmp(expr->fn->symbol->ident->name, allocator_info[i].name) == 0)
  94      -                        break;
  95      -        }
  96      -        if (i == ARRAY_SIZE(allocator_info))
  97      -                return false;
      115 +static void update_mtag_info(struct expression *expr, mtag_t tag,
      116 +                             const char *left_name, const char *tag_info,
      117 +                             struct smatch_state *state)
      118 +{
      119 +        char *allocator;
  98  120  
  99      -        arg = get_argument_from_call_expr(expr->args, allocator_info[i].size_arg);
 100      -        if (!get_implied_value(arg, &sval))
 101      -                return false;
      121 +        sql_insert_mtag_about(tag, left_name, tag_info);
 102  122  
 103      -        return true;
      123 +        allocator = get_allocator_info(expr, state);
      124 +        if (allocator)
      125 +                sql_insert_mtag_info(tag, ALLOCATOR, allocator);
 104  126  }
 105  127  
 106      -struct smatch_state *swap_mtag_return(struct expression *expr, struct smatch_state *state)
      128 +struct smatch_state *get_mtag_return(struct expression *expr, struct smatch_state *state)
 107  129  {
 108  130          struct expression *left, *right;
 109  131          char *left_name, *right_name;
 110  132          struct symbol *left_sym;
 111  133          struct range_list *rl;
 112  134          char buf[256];
 113  135          mtag_t tag;
 114  136          sval_t tag_sval;
 115  137  
 116  138          if (!expr || expr->type != EXPR_ASSIGNMENT || expr->op != '=')
 117      -                return state;
      139 +                return NULL;
      140 +        if (!is_fresh_alloc(expr->right))
      141 +                return NULL;
      142 +        if (!rl_intersection(estate_rl(state), valid_ptr_rl))
      143 +                return NULL;
 118  144  
 119      -        if (!estate_rl(state) || strcmp(state->name, "0,4096-ptr_max") != 0)
 120      -                return state;
 121      -
 122  145          left = strip_expr(expr->left);
 123  146          right = strip_expr(expr->right);
 124  147  
 125      -        if (!is_mtag_call(right))
 126      -                return state;
 127      -
 128  148          left_name = expr_to_str_sym(left, &left_sym);
 129  149          if (!left_name || !left_sym)
 130      -                return state;
      150 +                return NULL;
 131  151          right_name = expr_to_str(right);
 132  152  
 133  153          snprintf(buf, sizeof(buf), "%s %s %s %s", get_filename(), get_function(),
 134  154                   left_name, right_name);
 135  155          tag = str_to_mtag(buf);
 136  156          tag_sval.type = estate_type(state);
 137  157          tag_sval.uvalue = tag;
 138  158  
 139  159          rl = rl_filter(estate_rl(state), valid_ptr_rl);
 140  160          rl = clone_rl(rl);
 141  161          add_range(&rl, tag_sval, tag_sval);
 142  162  
 143      -        sql_insert_mtag_about(tag, left_name, buf);
      163 +        update_mtag_info(expr, tag, left_name, buf, state);
 144  164  
 145  165          free_string(left_name);
 146  166          free_string(right_name);
 147  167  
 148  168          return alloc_estate_rl(rl);
 149  169  }
 150  170  
 151  171  int get_string_mtag(struct expression *expr, mtag_t *tag)
 152  172  {
 153  173          mtag_t xor;
↓ open down ↓ 301 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX