1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2021 Microsoft Corporation 4 * 5 * Author: Tushar Sugandhi <tusharsu@linux.microsoft.com> 6 * 7 * File: dm-ima.c 8 * Enables IMA measurements for DM targets 9 */ 10 11 #include "dm-core.h" 12 #include "dm-ima.h" 13 14 #include <linux/ima.h> 15 #include <crypto/hash.h> 16 #include <linux/crypto.h> 17 #include <crypto/hash_info.h> 18 19 #define DM_MSG_PREFIX "ima" 20 21 /* 22 * Internal function to prefix separator characters in input buffer with escape 23 * character, so that they don't interfere with the construction of key-value pairs, 24 * and clients can split the key1=val1,key2=val2,key3=val3; pairs properly. 25 */ 26 static void fix_separator_chars(char **buf) 27 { 28 int l = strlen(*buf); 29 int i, j, sp = 0; 30 31 for (i = 0; i < l; i++) 32 if ((*buf)[i] == '\\' || (*buf)[i] == ';' || (*buf)[i] == '=' || (*buf)[i] == ',') 33 sp++; 34 35 if (!sp) 36 return; 37 38 for (i = l-1, j = i+sp; i >= 0; i--) { 39 (*buf)[j--] = (*buf)[i]; 40 if ((*buf)[i] == '\\' || (*buf)[i] == ';' || (*buf)[i] == '=' || (*buf)[i] == ',') 41 (*buf)[j--] = '\\'; 42 } 43 } 44 45 /* 46 * Internal function to allocate memory for IMA measurements. 47 */ 48 static void *dm_ima_alloc(size_t len, gfp_t flags, bool noio) 49 { 50 unsigned int noio_flag; 51 void *ptr; 52 53 if (noio) 54 noio_flag = memalloc_noio_save(); 55 56 ptr = kzalloc(len, flags); 57 58 if (noio) 59 memalloc_noio_restore(noio_flag); 60 61 return ptr; 62 } 63 64 /* 65 * Internal function to allocate and copy name and uuid for IMA measurements. 66 */ 67 static int dm_ima_alloc_and_copy_name_uuid(struct mapped_device *md, char **dev_name, 68 char **dev_uuid, bool noio) 69 { 70 int r; 71 *dev_name = dm_ima_alloc(DM_NAME_LEN*2, GFP_KERNEL, noio); 72 if (!(*dev_name)) { 73 r = -ENOMEM; 74 goto error; 75 } 76 77 *dev_uuid = dm_ima_alloc(DM_UUID_LEN*2, GFP_KERNEL, noio); 78 if (!(*dev_uuid)) { 79 r = -ENOMEM; 80 goto error; 81 } 82 83 r = dm_copy_name_and_uuid(md, *dev_name, *dev_uuid); 84 if (r) 85 goto error; 86 87 fix_separator_chars(dev_name); 88 fix_separator_chars(dev_uuid); 89 90 return 0; 91 error: 92 kfree(*dev_name); 93 kfree(*dev_uuid); 94 *dev_name = NULL; 95 *dev_uuid = NULL; 96 return r; 97 } 98 99 /* 100 * Internal function to allocate and copy device data for IMA measurements. 101 */ 102 static int dm_ima_alloc_and_copy_device_data(struct mapped_device *md, char **device_data, 103 unsigned int num_targets, bool noio) 104 { 105 char *dev_name = NULL, *dev_uuid = NULL; 106 int r; 107 108 r = dm_ima_alloc_and_copy_name_uuid(md, &dev_name, &dev_uuid, noio); 109 if (r) 110 return r; 111 112 *device_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, GFP_KERNEL, noio); 113 if (!(*device_data)) { 114 r = -ENOMEM; 115 goto error; 116 } 117 118 scnprintf(*device_data, DM_IMA_DEVICE_BUF_LEN, 119 "name=%s,uuid=%s,major=%d,minor=%d,minor_count=%d,num_targets=%u;", 120 dev_name, dev_uuid, md->disk->major, md->disk->first_minor, 121 md->disk->minors, num_targets); 122 error: 123 kfree(dev_name); 124 kfree(dev_uuid); 125 return r; 126 } 127 128 /* 129 * Internal wrapper function to call IMA to measure DM data. 130 */ 131 static void dm_ima_measure_data(const char *event_name, const void *buf, size_t buf_len, 132 bool noio) 133 { 134 unsigned int noio_flag; 135 136 if (noio) 137 noio_flag = memalloc_noio_save(); 138 139 ima_measure_critical_data(DM_NAME, event_name, buf, buf_len, 140 false, NULL, 0); 141 142 if (noio) 143 memalloc_noio_restore(noio_flag); 144 } 145 146 /* 147 * Internal function to allocate and copy current device capacity for IMA measurements. 148 */ 149 static int dm_ima_alloc_and_copy_capacity_str(struct mapped_device *md, char **capacity_str, 150 bool noio) 151 { 152 sector_t capacity; 153 154 capacity = get_capacity(md->disk); 155 156 *capacity_str = dm_ima_alloc(DM_IMA_DEVICE_CAPACITY_BUF_LEN, GFP_KERNEL, noio); 157 if (!(*capacity_str)) 158 return -ENOMEM; 159 160 scnprintf(*capacity_str, DM_IMA_DEVICE_BUF_LEN, "current_device_capacity=%llu;", 161 capacity); 162 163 return 0; 164 } 165 166 /* 167 * Initialize/reset the dm ima related data structure variables. 168 */ 169 void dm_ima_reset_data(struct mapped_device *md) 170 { 171 memset(&(md->ima), 0, sizeof(md->ima)); 172 md->ima.dm_version_str_len = strlen(DM_IMA_VERSION_STR); 173 } 174 175 /* 176 * Build up the IMA data for each target, and finally measure. 177 */ 178 void dm_ima_measure_on_table_load(struct dm_table *table, unsigned int status_flags) 179 { 180 size_t device_data_buf_len, target_metadata_buf_len, target_data_buf_len, l = 0; 181 char *target_metadata_buf = NULL, *target_data_buf = NULL, *digest_buf = NULL; 182 char *ima_buf = NULL, *device_data_buf = NULL; 183 int digest_size, last_target_measured = -1, r; 184 status_type_t type = STATUSTYPE_IMA; 185 size_t cur_total_buf_len = 0; 186 unsigned int num_targets, i; 187 SHASH_DESC_ON_STACK(shash, NULL); 188 struct crypto_shash *tfm = NULL; 189 u8 *digest = NULL; 190 bool noio = false; 191 /* 192 * In below hash_alg_prefix_len assignment +1 is for the additional char (':'), 193 * when prefixing the hash value with the hash algorithm name. e.g. sha256:<hash_value>. 194 */ 195 const size_t hash_alg_prefix_len = strlen(DM_IMA_TABLE_HASH_ALG) + 1; 196 char table_load_event_name[] = "dm_table_load"; 197 198 ima_buf = dm_ima_alloc(DM_IMA_MEASUREMENT_BUF_LEN, GFP_KERNEL, noio); 199 if (!ima_buf) 200 return; 201 202 target_metadata_buf = dm_ima_alloc(DM_IMA_TARGET_METADATA_BUF_LEN, GFP_KERNEL, noio); 203 if (!target_metadata_buf) 204 goto error; 205 206 target_data_buf = dm_ima_alloc(DM_IMA_TARGET_DATA_BUF_LEN, GFP_KERNEL, noio); 207 if (!target_data_buf) 208 goto error; 209 210 num_targets = dm_table_get_num_targets(table); 211 212 if (dm_ima_alloc_and_copy_device_data(table->md, &device_data_buf, num_targets, noio)) 213 goto error; 214 215 tfm = crypto_alloc_shash(DM_IMA_TABLE_HASH_ALG, 0, 0); 216 if (IS_ERR(tfm)) 217 goto error; 218 219 shash->tfm = tfm; 220 digest_size = crypto_shash_digestsize(tfm); 221 digest = dm_ima_alloc(digest_size, GFP_KERNEL, noio); 222 if (!digest) 223 goto error; 224 225 r = crypto_shash_init(shash); 226 if (r) 227 goto error; 228 229 memcpy(ima_buf + l, DM_IMA_VERSION_STR, table->md->ima.dm_version_str_len); 230 l += table->md->ima.dm_version_str_len; 231 232 device_data_buf_len = strlen(device_data_buf); 233 memcpy(ima_buf + l, device_data_buf, device_data_buf_len); 234 l += device_data_buf_len; 235 236 for (i = 0; i < num_targets; i++) { 237 struct dm_target *ti = dm_table_get_target(table, i); 238 239 if (!ti) 240 goto error; 241 242 last_target_measured = 0; 243 244 /* 245 * First retrieve the target metadata. 246 */ 247 scnprintf(target_metadata_buf, DM_IMA_TARGET_METADATA_BUF_LEN, 248 "target_index=%d,target_begin=%llu,target_len=%llu,", 249 i, ti->begin, ti->len); 250 target_metadata_buf_len = strlen(target_metadata_buf); 251 252 /* 253 * Then retrieve the actual target data. 254 */ 255 if (ti->type->status) 256 ti->type->status(ti, type, status_flags, target_data_buf, 257 DM_IMA_TARGET_DATA_BUF_LEN); 258 else 259 target_data_buf[0] = '\0'; 260 261 target_data_buf_len = strlen(target_data_buf); 262 263 /* 264 * Check if the total data can fit into the IMA buffer. 265 */ 266 cur_total_buf_len = l + target_metadata_buf_len + target_data_buf_len; 267 268 /* 269 * IMA measurements for DM targets are best-effort. 270 * If the total data buffered so far, including the current target, 271 * is too large to fit into DM_IMA_MEASUREMENT_BUF_LEN, measure what 272 * we have in the current buffer, and continue measuring the remaining 273 * targets by prefixing the device metadata again. 274 */ 275 if (unlikely(cur_total_buf_len >= DM_IMA_MEASUREMENT_BUF_LEN)) { 276 dm_ima_measure_data(table_load_event_name, ima_buf, l, noio); 277 r = crypto_shash_update(shash, (const u8 *)ima_buf, l); 278 if (r < 0) 279 goto error; 280 281 memset(ima_buf, 0, DM_IMA_MEASUREMENT_BUF_LEN); 282 l = 0; 283 284 /* 285 * Each new "dm_table_load" entry in IMA log should have device data 286 * prefix, so that multiple records from the same "dm_table_load" for 287 * a given device can be linked together. 288 */ 289 memcpy(ima_buf + l, DM_IMA_VERSION_STR, table->md->ima.dm_version_str_len); 290 l += table->md->ima.dm_version_str_len; 291 292 memcpy(ima_buf + l, device_data_buf, device_data_buf_len); 293 l += device_data_buf_len; 294 295 /* 296 * If this iteration of the for loop turns out to be the last target 297 * in the table, dm_ima_measure_data("dm_table_load", ...) doesn't need 298 * to be called again, just the hash needs to be finalized. 299 * "last_target_measured" tracks this state. 300 */ 301 last_target_measured = 1; 302 } 303 304 /* 305 * Fill-in all the target metadata, so that multiple targets for the same 306 * device can be linked together. 307 */ 308 memcpy(ima_buf + l, target_metadata_buf, target_metadata_buf_len); 309 l += target_metadata_buf_len; 310 311 memcpy(ima_buf + l, target_data_buf, target_data_buf_len); 312 l += target_data_buf_len; 313 } 314 315 if (!last_target_measured) { 316 dm_ima_measure_data(table_load_event_name, ima_buf, l, noio); 317 318 r = crypto_shash_update(shash, (const u8 *)ima_buf, l); 319 if (r < 0) 320 goto error; 321 } 322 323 /* 324 * Finalize the table hash, and store it in table->md->ima.inactive_table.hash, 325 * so that the table data can be verified against the future device state change 326 * events, e.g. resume, rename, remove, table-clear etc. 327 */ 328 r = crypto_shash_final(shash, digest); 329 if (r < 0) 330 goto error; 331 332 digest_buf = dm_ima_alloc((digest_size*2) + hash_alg_prefix_len + 1, GFP_KERNEL, noio); 333 334 if (!digest_buf) 335 goto error; 336 337 snprintf(digest_buf, hash_alg_prefix_len + 1, "%s:", DM_IMA_TABLE_HASH_ALG); 338 339 for (i = 0; i < digest_size; i++) 340 snprintf((digest_buf + hash_alg_prefix_len + (i*2)), 3, "%02x", digest[i]); 341 342 if (table->md->ima.active_table.hash != table->md->ima.inactive_table.hash) 343 kfree(table->md->ima.inactive_table.hash); 344 345 table->md->ima.inactive_table.hash = digest_buf; 346 table->md->ima.inactive_table.hash_len = strlen(digest_buf); 347 table->md->ima.inactive_table.num_targets = num_targets; 348 349 if (table->md->ima.active_table.device_metadata != 350 table->md->ima.inactive_table.device_metadata) 351 kfree(table->md->ima.inactive_table.device_metadata); 352 353 table->md->ima.inactive_table.device_metadata = device_data_buf; 354 table->md->ima.inactive_table.device_metadata_len = device_data_buf_len; 355 356 goto exit; 357 error: 358 kfree(digest_buf); 359 kfree(device_data_buf); 360 exit: 361 kfree(digest); 362 if (tfm) 363 crypto_free_shash(tfm); 364 kfree(ima_buf); 365 kfree(target_metadata_buf); 366 kfree(target_data_buf); 367 } 368 369 /* 370 * Measure IMA data on device resume. 371 */ 372 void dm_ima_measure_on_device_resume(struct mapped_device *md, bool swap) 373 { 374 char *device_table_data, *dev_name = NULL, *dev_uuid = NULL, *capacity_str = NULL; 375 char active[] = "active_table_hash="; 376 unsigned int active_len = strlen(active), capacity_len = 0; 377 unsigned int l = 0; 378 bool noio = true; 379 bool nodata = true; 380 int r; 381 382 device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, GFP_KERNEL, noio); 383 if (!device_table_data) 384 return; 385 386 r = dm_ima_alloc_and_copy_capacity_str(md, &capacity_str, noio); 387 if (r) 388 goto error; 389 390 memcpy(device_table_data + l, DM_IMA_VERSION_STR, md->ima.dm_version_str_len); 391 l += md->ima.dm_version_str_len; 392 393 if (swap) { 394 if (md->ima.active_table.hash != md->ima.inactive_table.hash) 395 kfree(md->ima.active_table.hash); 396 397 md->ima.active_table.hash = NULL; 398 md->ima.active_table.hash_len = 0; 399 400 if (md->ima.active_table.device_metadata != 401 md->ima.inactive_table.device_metadata) 402 kfree(md->ima.active_table.device_metadata); 403 404 md->ima.active_table.device_metadata = NULL; 405 md->ima.active_table.device_metadata_len = 0; 406 md->ima.active_table.num_targets = 0; 407 408 if (md->ima.inactive_table.hash) { 409 md->ima.active_table.hash = md->ima.inactive_table.hash; 410 md->ima.active_table.hash_len = md->ima.inactive_table.hash_len; 411 md->ima.inactive_table.hash = NULL; 412 md->ima.inactive_table.hash_len = 0; 413 } 414 415 if (md->ima.inactive_table.device_metadata) { 416 md->ima.active_table.device_metadata = 417 md->ima.inactive_table.device_metadata; 418 md->ima.active_table.device_metadata_len = 419 md->ima.inactive_table.device_metadata_len; 420 md->ima.active_table.num_targets = md->ima.inactive_table.num_targets; 421 md->ima.inactive_table.device_metadata = NULL; 422 md->ima.inactive_table.device_metadata_len = 0; 423 md->ima.inactive_table.num_targets = 0; 424 } 425 } 426 427 if (md->ima.active_table.device_metadata) { 428 memcpy(device_table_data + l, md->ima.active_table.device_metadata, 429 md->ima.active_table.device_metadata_len); 430 l += md->ima.active_table.device_metadata_len; 431 432 nodata = false; 433 } 434 435 if (md->ima.active_table.hash) { 436 memcpy(device_table_data + l, active, active_len); 437 l += active_len; 438 439 memcpy(device_table_data + l, md->ima.active_table.hash, 440 md->ima.active_table.hash_len); 441 l += md->ima.active_table.hash_len; 442 443 memcpy(device_table_data + l, ";", 1); 444 l++; 445 446 nodata = false; 447 } 448 449 if (nodata) { 450 r = dm_ima_alloc_and_copy_name_uuid(md, &dev_name, &dev_uuid, noio); 451 if (r) 452 goto error; 453 454 scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN, 455 "%sname=%s,uuid=%s;device_resume=no_data;", 456 DM_IMA_VERSION_STR, dev_name, dev_uuid); 457 l += strlen(device_table_data); 458 459 } 460 461 capacity_len = strlen(capacity_str); 462 memcpy(device_table_data + l, capacity_str, capacity_len); 463 l += capacity_len; 464 465 dm_ima_measure_data("dm_device_resume", device_table_data, l, noio); 466 467 kfree(dev_name); 468 kfree(dev_uuid); 469 error: 470 kfree(capacity_str); 471 kfree(device_table_data); 472 } 473 474 /* 475 * Measure IMA data on remove. 476 */ 477 void dm_ima_measure_on_device_remove(struct mapped_device *md, bool remove_all) 478 { 479 char *device_table_data, *dev_name = NULL, *dev_uuid = NULL, *capacity_str = NULL; 480 char active_table_str[] = "active_table_hash="; 481 char inactive_table_str[] = "inactive_table_hash="; 482 char device_active_str[] = "device_active_metadata="; 483 char device_inactive_str[] = "device_inactive_metadata="; 484 char remove_all_str[] = "remove_all="; 485 unsigned int active_table_len = strlen(active_table_str); 486 unsigned int inactive_table_len = strlen(inactive_table_str); 487 unsigned int device_active_len = strlen(device_active_str); 488 unsigned int device_inactive_len = strlen(device_inactive_str); 489 unsigned int remove_all_len = strlen(remove_all_str); 490 unsigned int capacity_len = 0; 491 unsigned int l = 0; 492 bool noio = true; 493 bool nodata = true; 494 int r; 495 496 device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN*2, GFP_KERNEL, noio); 497 if (!device_table_data) 498 goto exit; 499 500 r = dm_ima_alloc_and_copy_capacity_str(md, &capacity_str, noio); 501 if (r) { 502 kfree(device_table_data); 503 goto exit; 504 } 505 506 memcpy(device_table_data + l, DM_IMA_VERSION_STR, md->ima.dm_version_str_len); 507 l += md->ima.dm_version_str_len; 508 509 if (md->ima.active_table.device_metadata) { 510 memcpy(device_table_data + l, device_active_str, device_active_len); 511 l += device_active_len; 512 513 memcpy(device_table_data + l, md->ima.active_table.device_metadata, 514 md->ima.active_table.device_metadata_len); 515 l += md->ima.active_table.device_metadata_len; 516 517 nodata = false; 518 } 519 520 if (md->ima.inactive_table.device_metadata) { 521 memcpy(device_table_data + l, device_inactive_str, device_inactive_len); 522 l += device_inactive_len; 523 524 memcpy(device_table_data + l, md->ima.inactive_table.device_metadata, 525 md->ima.inactive_table.device_metadata_len); 526 l += md->ima.inactive_table.device_metadata_len; 527 528 nodata = false; 529 } 530 531 if (md->ima.active_table.hash) { 532 memcpy(device_table_data + l, active_table_str, active_table_len); 533 l += active_table_len; 534 535 memcpy(device_table_data + l, md->ima.active_table.hash, 536 md->ima.active_table.hash_len); 537 l += md->ima.active_table.hash_len; 538 539 memcpy(device_table_data + l, ",", 1); 540 l++; 541 542 nodata = false; 543 } 544 545 if (md->ima.inactive_table.hash) { 546 memcpy(device_table_data + l, inactive_table_str, inactive_table_len); 547 l += inactive_table_len; 548 549 memcpy(device_table_data + l, md->ima.inactive_table.hash, 550 md->ima.inactive_table.hash_len); 551 l += md->ima.inactive_table.hash_len; 552 553 memcpy(device_table_data + l, ",", 1); 554 l++; 555 556 nodata = false; 557 } 558 /* 559 * In case both active and inactive tables, and corresponding 560 * device metadata is cleared/missing - record the name and uuid 561 * in IMA measurements. 562 */ 563 if (nodata) { 564 if (dm_ima_alloc_and_copy_name_uuid(md, &dev_name, &dev_uuid, noio)) 565 goto error; 566 567 scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN, 568 "%sname=%s,uuid=%s;device_remove=no_data;", 569 DM_IMA_VERSION_STR, dev_name, dev_uuid); 570 l += strlen(device_table_data); 571 } 572 573 memcpy(device_table_data + l, remove_all_str, remove_all_len); 574 l += remove_all_len; 575 memcpy(device_table_data + l, remove_all ? "y;" : "n;", 2); 576 l += 2; 577 578 capacity_len = strlen(capacity_str); 579 memcpy(device_table_data + l, capacity_str, capacity_len); 580 l += capacity_len; 581 582 dm_ima_measure_data("dm_device_remove", device_table_data, l, noio); 583 584 error: 585 kfree(device_table_data); 586 kfree(capacity_str); 587 exit: 588 kfree(md->ima.active_table.device_metadata); 589 590 if (md->ima.active_table.device_metadata != 591 md->ima.inactive_table.device_metadata) 592 kfree(md->ima.inactive_table.device_metadata); 593 594 kfree(md->ima.active_table.hash); 595 596 if (md->ima.active_table.hash != md->ima.inactive_table.hash) 597 kfree(md->ima.inactive_table.hash); 598 599 dm_ima_reset_data(md); 600 601 kfree(dev_name); 602 kfree(dev_uuid); 603 } 604 605 /* 606 * Measure ima data on table clear. 607 */ 608 void dm_ima_measure_on_table_clear(struct mapped_device *md, bool new_map) 609 { 610 unsigned int l = 0, capacity_len = 0; 611 char *device_table_data = NULL, *dev_name = NULL, *dev_uuid = NULL, *capacity_str = NULL; 612 char inactive_str[] = "inactive_table_hash="; 613 unsigned int inactive_len = strlen(inactive_str); 614 bool noio = true; 615 bool nodata = true; 616 int r; 617 618 device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, GFP_KERNEL, noio); 619 if (!device_table_data) 620 return; 621 622 r = dm_ima_alloc_and_copy_capacity_str(md, &capacity_str, noio); 623 if (r) 624 goto error1; 625 626 memcpy(device_table_data + l, DM_IMA_VERSION_STR, md->ima.dm_version_str_len); 627 l += md->ima.dm_version_str_len; 628 629 if (md->ima.inactive_table.device_metadata_len && 630 md->ima.inactive_table.hash_len) { 631 memcpy(device_table_data + l, md->ima.inactive_table.device_metadata, 632 md->ima.inactive_table.device_metadata_len); 633 l += md->ima.inactive_table.device_metadata_len; 634 635 memcpy(device_table_data + l, inactive_str, inactive_len); 636 l += inactive_len; 637 638 memcpy(device_table_data + l, md->ima.inactive_table.hash, 639 md->ima.inactive_table.hash_len); 640 641 l += md->ima.inactive_table.hash_len; 642 643 memcpy(device_table_data + l, ";", 1); 644 l++; 645 646 nodata = false; 647 } 648 649 if (nodata) { 650 if (dm_ima_alloc_and_copy_name_uuid(md, &dev_name, &dev_uuid, noio)) 651 goto error2; 652 653 scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN, 654 "%sname=%s,uuid=%s;table_clear=no_data;", 655 DM_IMA_VERSION_STR, dev_name, dev_uuid); 656 l += strlen(device_table_data); 657 } 658 659 capacity_len = strlen(capacity_str); 660 memcpy(device_table_data + l, capacity_str, capacity_len); 661 l += capacity_len; 662 663 dm_ima_measure_data("dm_table_clear", device_table_data, l, noio); 664 665 if (new_map) { 666 if (md->ima.inactive_table.hash && 667 md->ima.inactive_table.hash != md->ima.active_table.hash) 668 kfree(md->ima.inactive_table.hash); 669 670 md->ima.inactive_table.hash = NULL; 671 md->ima.inactive_table.hash_len = 0; 672 673 if (md->ima.inactive_table.device_metadata && 674 md->ima.inactive_table.device_metadata != md->ima.active_table.device_metadata) 675 kfree(md->ima.inactive_table.device_metadata); 676 677 md->ima.inactive_table.device_metadata = NULL; 678 md->ima.inactive_table.device_metadata_len = 0; 679 md->ima.inactive_table.num_targets = 0; 680 681 if (md->ima.active_table.hash) { 682 md->ima.inactive_table.hash = md->ima.active_table.hash; 683 md->ima.inactive_table.hash_len = md->ima.active_table.hash_len; 684 } 685 686 if (md->ima.active_table.device_metadata) { 687 md->ima.inactive_table.device_metadata = 688 md->ima.active_table.device_metadata; 689 md->ima.inactive_table.device_metadata_len = 690 md->ima.active_table.device_metadata_len; 691 md->ima.inactive_table.num_targets = 692 md->ima.active_table.num_targets; 693 } 694 } 695 696 kfree(dev_name); 697 kfree(dev_uuid); 698 error2: 699 kfree(capacity_str); 700 error1: 701 kfree(device_table_data); 702 } 703 704 /* 705 * Measure IMA data on device rename. 706 */ 707 void dm_ima_measure_on_device_rename(struct mapped_device *md) 708 { 709 char *old_device_data = NULL, *new_device_data = NULL, *combined_device_data = NULL; 710 char *new_dev_name = NULL, *new_dev_uuid = NULL, *capacity_str = NULL; 711 bool noio = true; 712 int r; 713 714 if (dm_ima_alloc_and_copy_device_data(md, &new_device_data, 715 md->ima.active_table.num_targets, noio)) 716 return; 717 718 if (dm_ima_alloc_and_copy_name_uuid(md, &new_dev_name, &new_dev_uuid, noio)) 719 goto error; 720 721 combined_device_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN * 2, GFP_KERNEL, noio); 722 if (!combined_device_data) 723 goto error; 724 725 r = dm_ima_alloc_and_copy_capacity_str(md, &capacity_str, noio); 726 if (r) 727 goto error; 728 729 old_device_data = md->ima.active_table.device_metadata; 730 731 md->ima.active_table.device_metadata = new_device_data; 732 md->ima.active_table.device_metadata_len = strlen(new_device_data); 733 734 scnprintf(combined_device_data, DM_IMA_DEVICE_BUF_LEN * 2, 735 "%s%snew_name=%s,new_uuid=%s;%s", DM_IMA_VERSION_STR, old_device_data, 736 new_dev_name, new_dev_uuid, capacity_str); 737 738 dm_ima_measure_data("dm_device_rename", combined_device_data, strlen(combined_device_data), 739 noio); 740 741 goto exit; 742 743 error: 744 kfree(new_device_data); 745 exit: 746 kfree(capacity_str); 747 kfree(combined_device_data); 748 kfree(old_device_data); 749 kfree(new_dev_name); 750 kfree(new_dev_uuid); 751 } 752