smatch_mtag_data.c

   1 /*
   2  * Copyright (C) 2016 Oracle.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 /*
  19  * What we're doing here is saving all the possible values for static variables.
  20  * Later on we might do globals as well.
  21  *
  22  */
  23
  24 #include "smatch.h"
  25 #include "smatch_slist.h"
  26 #include "smatch_extra.h"
  27
  28 static int my_id;
  29 static struct stree *vals;
  30
  31 static int save_rl(void *_rl, int argc, char **argv, char **azColName)
  32 {
  33         unsigned long *rl = _rl;
  34
  35         *rl = strtoul(argv[0], NULL, 10);
  36         return 0;
  37 }
  38
  39 static struct range_list *select_orig(mtag_t tag, int offset)
  40 {
  41         struct range_list *rl = NULL;
  42
  43         mem_sql(&save_rl, &rl, "select value from mtag_data where tag = %lld and offset = %d;",
  44                 tag, offset);
  45         return rl;
  46 }
  47
  48 static int is_kernel_param(const char *name)
  49 {
  50         struct sm_state *tmp;
  51         char buf[256];
  52
  53         /*
  54          * I'm ignoring these because otherwise Smatch thinks that kernel
  55          * parameters are always set to the default.
  56          *
  57          */
  58
  59         if (option_project != PROJ_KERNEL)
  60                 return 0;
  61
  62         snprintf(buf, sizeof(buf), "__param_%s.arg", name);
  63
  64         FOR_EACH_SM(vals, tmp) {
  65                 if (strcmp(tmp->name, buf) == 0)
  66                         return 1;
  67         } END_FOR_EACH_SM(tmp);
  68
  69         return 0;
  70 }
  71
  72 static bool is_ignored_macro(struct expression *expr)
  73 {
  74         char *macro;
  75
  76         macro = get_macro_name(expr->pos);
  77         if (!macro)
  78                 return false;
  79         if (strcmp(macro, "EXPORT_SYMBOL") == 0)
  80                 return true;
  81         return false;
  82 }
  83
  84 static bool is_head_next(struct expression *expr)
  85 {
  86         struct symbol *type;
  87
  88         /* Smatch thinks head->next == head is always true.  *sad face* */
  89
  90         if (option_project != PROJ_KERNEL)
  91                 return false;
  92
  93         if (expr->type != EXPR_DEREF)
  94                 return false;
  95         if (!expr->member || strcmp(expr->member->name, "next") != 0)
  96                 return false;
  97
  98         type = get_type(expr->deref);
  99         if (!type)
 100                 return false;
 101         if (type->type == SYM_PTR)
 102                 type = get_real_base_type(type);
 103         if (type->type != SYM_STRUCT)
 104                 return false;
 105         if (!type->ident || strcmp(type->ident->name, "list_head") != 0)
 106                 return false;
 107         return true;
 108 }
 109
 110 mtag_t ignored_mtag;
 111 static bool is_ignored_tag(mtag_t tag)
 112 {
 113         if (tag == ignored_mtag)
 114                 return true;
 115         return false;
 116 }
 117
 118 static void insert_mtag_data(mtag_t tag, int offset, struct range_list *rl)
 119 {
 120         if (in_fake_env)
 121                 return;
 122         if (is_ignored_tag(tag))
 123                 return;
 124
 125         rl = clone_rl_permanent(rl);
 126
 127         mem_sql(NULL, NULL, "delete from mtag_data where tag = %lld and offset = %d and type = %d",
 128                 tag, offset, DATA_VALUE);
 129         mem_sql(NULL, NULL, "insert into mtag_data values (%lld, %d, %d, '%lu');",
 130                 tag, offset, DATA_VALUE, (unsigned long)rl);
 131 }
 132
 133 static bool invalid_type(struct symbol *type)
 134 {
 135         if (!type)
 136                 return true;
 137         if (type == &void_ctype)
 138                 return true;
 139         if (type->type == SYM_STRUCT ||
 140             type->type == SYM_ARRAY ||
 141             type->type == SYM_UNION)
 142                 return true;
 143         return false;
 144 }
 145
 146 static bool parent_is_fresh_alloc(struct expression *expr)
 147 {
 148         struct symbol *sym;
 149
 150         sym = expr_to_sym(expr);
 151         if (!sym || !sym->ident)
 152                 return false;
 153         return is_fresh_alloc_var_sym(sym->ident->name, sym);
 154 }
 155
 156 void update_mtag_data(struct expression *expr, struct smatch_state *state)
 157 {
 158         struct range_list *orig, *new;
 159         struct symbol *type;
 160         char *name;
 161         mtag_t tag;
 162         int offset;
 163
 164         if (!expr)
 165                 return;
 166         if (is_ignored_macro(expr))
 167                 return;
 168         if (is_head_next(expr))
 169                 return;
 170         name = expr_to_var(expr);
 171         if (is_kernel_param(name)) {
 172                 free_string(name);
 173                 return;
 174         }
 175         free_string(name);
 176
 177         if (!expr_to_mtag_offset(expr, &tag, &offset))
 178                 return;
 179
 180         type = get_type(expr);
 181         if (offset == 0 && invalid_type(type))
 182                 return;
 183
 184         if (parent_is_fresh_alloc(expr))
 185                 orig = NULL;
 186         else
 187                 orig = select_orig(tag, offset);
 188         new = rl_union(orig, estate_rl(state));
 189         insert_mtag_data(tag, offset, new);
 190 }
 191
 192 static void match_global_assign(struct expression *expr)
 193 {
 194         struct range_list *rl;
 195         mtag_t tag;
 196         int offset;
 197         char *name;
 198
 199         if (is_ignored_macro(expr))
 200                 return;
 201         if (is_head_next(expr->left))
 202                 return;
 203         name = expr_to_var(expr->left);
 204         if (is_kernel_param(name)) {
 205                 free_string(name);
 206                 return;
 207         }
 208         free_string(name);
 209
 210         if (!expr_to_mtag_offset(expr->left, &tag, &offset))
 211                 return;
 212
 213         get_absolute_rl(expr->right, &rl);
 214         insert_mtag_data(tag, offset, rl);
 215 }
 216
 217 static int save_mtag_data(void *_unused, int argc, char **argv, char **azColName)
 218 {
 219         struct range_list *rl;
 220
 221         if (argc != 4) {
 222                 sm_msg("Error saving mtag data");
 223                 return 0;
 224         }
 225         if (!option_info)
 226                 return 0;
 227
 228         rl = (struct range_list *)strtoul(argv[3], NULL, 10);
 229         sm_msg("SQL: insert or ignore into mtag_data values ('%s', '%s', '%s', '%s');",
 230                argv[0], argv[1], argv[2], show_rl(rl));
 231
 232         return 0;
 233 }
 234
 235 static void match_end_file(struct symbol_list *sym_list)
 236 {
 237         mem_sql(&save_mtag_data, NULL, "select * from mtag_data where type = %d;",
 238                 DATA_VALUE);
 239 }
 240
 241 struct db_info {
 242         struct symbol *type;
 243         struct range_list *rl;
 244 };
 245
 246 static int get_vals(void *_db_info, int argc, char **argv, char **azColName)
 247 {
 248         struct db_info *db_info = _db_info;
 249         struct range_list *tmp;
 250
 251         str_to_rl(db_info->type, argv[0], &tmp);
 252         if (db_info->rl)
 253                 db_info->rl = rl_union(db_info->rl, tmp);
 254         else
 255                 db_info->rl = tmp;
 256
 257         return 0;
 258 }
 259
 260 struct db_cache_results {
 261         mtag_t tag;
 262         struct range_list *rl;
 263 };
 264 static struct db_cache_results cached_results[8];
 265
 266 static int get_rl_from_mtag_offset(mtag_t tag, int offset, struct symbol *type, struct range_list **rl)
 267 {
 268         struct db_info db_info = {};
 269         mtag_t merged = tag | offset;
 270         struct range_list *mem_rl;
 271         static int idx;
 272         int i;
 273
 274         *rl = NULL;
 275
 276         for (i = 0; i < ARRAY_SIZE(cached_results); i++) {
 277                 if (merged == cached_results[i].tag) {
 278                         if (cached_results[i].rl) {
 279                                 *rl = cached_results[i].rl;
 280                                 return 1;
 281                         }
 282                         return 0;
 283                 }
 284         }
 285
 286         mem_rl = select_orig(tag, offset);
 287         if (is_whole_rl(mem_rl))
 288                 goto update_cache;
 289
 290         db_info.type = type;
 291         run_sql(get_vals, &db_info,
 292                 "select value from mtag_data where tag = %lld and offset = %d and type = %d;",
 293                 tag, offset, DATA_VALUE);
 294         if (!db_info.rl)
 295                 goto update_cache;
 296         db_info.rl = rl_union(mem_rl, db_info.rl);
 297         if (is_whole_rl(db_info.rl))
 298                 goto update_cache;
 299
 300         *rl = db_info.rl;
 301
 302 update_cache:
 303         cached_results[idx].tag = merged;
 304         cached_results[idx].rl = *rl;
 305         idx = (idx + 1) % ARRAY_SIZE(cached_results);
 306
 307         return !!*rl;
 308 }
 309
 310 static void clear_cache(struct symbol *sym)
 311 {
 312         memset(cached_results, 0, sizeof(cached_results));
 313 }
 314
 315 int get_mtag_rl(struct expression *expr, struct range_list **rl)
 316 {
 317         struct symbol *type;
 318         mtag_t tag;
 319         int offset;
 320
 321         if (is_local_variable(expr))
 322                 return 0;
 323         if (!expr_to_mtag_offset(expr, &tag, &offset))
 324                 return 0;
 325         if (offset >= MTAG_OFFSET_MASK)
 326                 return 0;
 327
 328         type = get_type(expr);
 329         if (invalid_type(type))
 330                 return 0;
 331
 332         return get_rl_from_mtag_offset(tag, offset, type, rl);
 333 }
 334
 335 void register_mtag_data(int id)
 336 {
 337         my_id = id;
 338
 339         ignored_mtag = str_to_mtag("extern boot_params");
 340         add_hook(&clear_cache, FUNC_DEF_HOOK);
 341
 342         if (!option_info)
 343                 return;
 344         add_hook(&match_global_assign, GLOBAL_ASSIGNMENT_HOOK);
 345         add_hook(&match_end_file, END_FILE_HOOK);
 346 }
 347