drivers/md/dm-android-verity.c

   1 /*
   2  * Copyright (C) 2015 Google, Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14
  15 #include <linux/buffer_head.h>
  16 #include <linux/debugfs.h>
  17 #include <linux/delay.h>
  18 #include <linux/device.h>
  19 #include <linux/device-mapper.h>
  20 #include <linux/errno.h>
  21 #include <linux/fs.h>
  22 #include <linux/fcntl.h>
  23 #include <linux/init.h>
  24 #include <linux/kernel.h>
  25 #include <linux/key.h>
  26 #include <linux/module.h>
  27 #include <linux/mount.h>
  28 #include <linux/namei.h>
  29 #include <linux/of.h>
  30 #include <linux/reboot.h>
  31 #include <linux/string.h>
  32 #include <linux/vmalloc.h>
  33
  34 #include <asm/setup.h>
  35 #include <crypto/hash.h>
  36 #include <crypto/public_key.h>
  37 #include <crypto/sha.h>
  38 #include <keys/asymmetric-type.h>
  39 #include <keys/system_keyring.h>
  40
  41 #include "dm-verity.h"
  42 #include "dm-android-verity.h"
  43
  44 static char verifiedbootstate[VERITY_COMMANDLINE_PARAM_LENGTH];
  45 static char veritymode[VERITY_COMMANDLINE_PARAM_LENGTH];
  46 static char veritykeyid[VERITY_DEFAULT_KEY_ID_LENGTH];
  47 static char buildvariant[BUILD_VARIANT];
  48
  49 static bool target_added;
  50 static bool verity_enabled = true;
  51 struct dentry *debug_dir;
  52 static int android_verity_ctr(struct dm_target *ti, unsigned argc, char **argv);
  53
  54 static struct target_type android_verity_target = {
  55         .name                   = "android-verity",
  56         .version                = {1, 0, 0},
  57         .module                 = THIS_MODULE,
  58         .ctr                    = android_verity_ctr,
  59         .dtr                    = verity_dtr,
  60         .map                    = verity_map,
  61         .status                 = verity_status,
  62         .ioctl                  = verity_ioctl,
  63         .merge                  = verity_merge,
  64         .iterate_devices        = verity_iterate_devices,
  65         .io_hints               = verity_io_hints,
  66 };
  67
  68 static int __init verified_boot_state_param(char *line)
  69 {
  70         strlcpy(verifiedbootstate, line, sizeof(verifiedbootstate));
  71         return 1;
  72 }
  73
  74 __setup("androidboot.verifiedbootstate=", verified_boot_state_param);
  75
  76 static int __init verity_mode_param(char *line)
  77 {
  78         strlcpy(veritymode, line, sizeof(veritymode));
  79         return 1;
  80 }
  81
  82 __setup("androidboot.veritymode=", verity_mode_param);
  83
  84 static int __init verity_keyid_param(char *line)
  85 {
  86         strlcpy(veritykeyid, line, sizeof(veritykeyid));
  87         return 1;
  88 }
  89
  90 __setup("veritykeyid=", verity_keyid_param);
  91
  92 static int __init verity_buildvariant(char *line)
  93 {
  94         strlcpy(buildvariant, line, sizeof(buildvariant));
  95         return 1;
  96 }
  97
  98 __setup("buildvariant=", verity_buildvariant);
  99
 100 static inline bool default_verity_key_id(void)
 101 {
 102         return veritykeyid[0] != '\0';
 103 }
 104
 105 static inline bool is_eng(void)
 106 {
 107         static const char typeeng[]  = "eng";
 108
 109         return !strncmp(buildvariant, typeeng, sizeof(typeeng));
 110 }
 111
 112 static inline bool is_userdebug(void)
 113 {
 114         static const char typeuserdebug[]  = "userdebug";
 115
 116         return !strncmp(buildvariant, typeuserdebug, sizeof(typeuserdebug));
 117 }
 118
 119
 120 static int table_extract_mpi_array(struct public_key_signature *pks,
 121                                 const void *data, size_t len)
 122 {
 123         MPI mpi = mpi_read_raw_data(data, len);
 124
 125         if (!mpi) {
 126                 DMERR("Error while allocating mpi array");
 127                 return -ENOMEM;
 128         }
 129
 130         pks->mpi[0] = mpi;
 131         pks->nr_mpi = 1;
 132         return 0;
 133 }
 134
 135 static struct public_key_signature *table_make_digest(
 136                                                 enum hash_algo hash,
 137                                                 const void *table,
 138                                                 unsigned long table_len)
 139 {
 140         struct public_key_signature *pks = NULL;
 141         struct crypto_shash *tfm;
 142         struct shash_desc *desc;
 143         size_t digest_size, desc_size;
 144         int ret;
 145
 146         /* Allocate the hashing algorithm we're going to need and find out how
 147          * big the hash operational data will be.
 148          */
 149         tfm = crypto_alloc_shash(hash_algo_name[hash], 0, 0);
 150         if (IS_ERR(tfm))
 151                 return ERR_CAST(tfm);
 152
 153         desc_size = crypto_shash_descsize(tfm) + sizeof(*desc);
 154         digest_size = crypto_shash_digestsize(tfm);
 155
 156         /* We allocate the hash operational data storage on the end of out
 157          * context data and the digest output buffer on the end of that.
 158          */
 159         ret = -ENOMEM;
 160         pks = kzalloc(digest_size + sizeof(*pks) + desc_size, GFP_KERNEL);
 161         if (!pks)
 162                 goto error;
 163
 164         pks->pkey_hash_algo = hash;
 165         pks->digest = (u8 *)pks + sizeof(*pks) + desc_size;
 166         pks->digest_size = digest_size;
 167
 168         desc = (struct shash_desc *)(pks + 1);
 169         desc->tfm = tfm;
 170         desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 171
 172         ret = crypto_shash_init(desc);
 173         if (ret < 0)
 174                 goto error;
 175
 176         ret = crypto_shash_finup(desc, table, table_len, pks->digest);
 177         if (ret < 0)
 178                 goto error;
 179
 180         crypto_free_shash(tfm);
 181         return pks;
 182
 183 error:
 184         kfree(pks);
 185         crypto_free_shash(tfm);
 186         return ERR_PTR(ret);
 187 }
 188
 189 static int read_block_dev(struct bio_read *payload, struct block_device *bdev,
 190                 sector_t offset, int length)
 191 {
 192         struct bio *bio;
 193         int err = 0, i;
 194
 195         payload->number_of_pages = DIV_ROUND_UP(length, PAGE_SIZE);
 196
 197         bio = bio_alloc(GFP_KERNEL, payload->number_of_pages);
 198         if (!bio) {
 199                 DMERR("Error while allocating bio");
 200                 return -ENOMEM;
 201         }
 202
 203         bio->bi_bdev = bdev;
 204         bio->bi_iter.bi_sector = offset;
 205
 206         payload->page_io = kzalloc(sizeof(struct page *) *
 207                 payload->number_of_pages, GFP_KERNEL);
 208         if (!payload->page_io) {
 209                 DMERR("page_io array alloc failed");
 210                 err = -ENOMEM;
 211                 goto free_bio;
 212         }
 213
 214         for (i = 0; i < payload->number_of_pages; i++) {
 215                 payload->page_io[i] = alloc_page(GFP_KERNEL);
 216                 if (!payload->page_io[i]) {
 217                         DMERR("alloc_page failed");
 218                         err = -ENOMEM;
 219                         goto free_pages;
 220                 }
 221                 if (!bio_add_page(bio, payload->page_io[i], PAGE_SIZE, 0)) {
 222                         DMERR("bio_add_page error");
 223                         err = -EIO;
 224                         goto free_pages;
 225                 }
 226         }
 227
 228         if (!submit_bio_wait(READ, bio))
 229                 /* success */
 230                 goto free_bio;
 231         DMERR("bio read failed");
 232         err = -EIO;
 233
 234 free_pages:
 235         for (i = 0; i < payload->number_of_pages; i++)
 236                 if (payload->page_io[i])
 237                         __free_page(payload->page_io[i]);
 238         kfree(payload->page_io);
 239 free_bio:
 240         bio_put(bio);
 241         return err;
 242 }
 243
 244 static inline u64 fec_div_round_up(u64 x, u64 y)
 245 {
 246         u64 remainder;
 247
 248         return div64_u64_rem(x, y, &remainder) +
 249                 (remainder > 0 ? 1 : 0);
 250 }
 251
 252 static inline void populate_fec_metadata(struct fec_header *header,
 253                                 struct fec_ecc_metadata *ecc)
 254 {
 255         ecc->blocks = fec_div_round_up(le64_to_cpu(header->inp_size),
 256                         FEC_BLOCK_SIZE);
 257         ecc->roots = le32_to_cpu(header->roots);
 258         ecc->start = le64_to_cpu(header->inp_size);
 259 }
 260
 261 static inline int validate_fec_header(struct fec_header *header, u64 offset)
 262 {
 263         /* move offset to make the sanity check work for backup header
 264          * as well. */
 265         offset -= offset % FEC_BLOCK_SIZE;
 266         if (le32_to_cpu(header->magic) != FEC_MAGIC ||
 267                 le32_to_cpu(header->version) != FEC_VERSION ||
 268                 le32_to_cpu(header->size) != sizeof(struct fec_header) ||
 269                 le32_to_cpu(header->roots) == 0 ||
 270                 le32_to_cpu(header->roots) >= FEC_RSM ||
 271                 offset < le32_to_cpu(header->fec_size) ||
 272                 offset - le32_to_cpu(header->fec_size) !=
 273                 le64_to_cpu(header->inp_size))
 274                 return -EINVAL;
 275
 276         return 0;
 277 }
 278
 279 static int extract_fec_header(dev_t dev, struct fec_header *fec,
 280                                 struct fec_ecc_metadata *ecc)
 281 {
 282         u64 device_size;
 283         struct bio_read payload;
 284         int i, err = 0;
 285         struct block_device *bdev;
 286
 287         bdev = blkdev_get_by_dev(dev, FMODE_READ, NULL);
 288
 289         if (IS_ERR_OR_NULL(bdev)) {
 290                 DMERR("bdev get error");
 291                 return PTR_ERR(bdev);
 292         }
 293
 294         device_size = i_size_read(bdev->bd_inode);
 295
 296         /* fec metadata size is a power of 2 and PAGE_SIZE
 297          * is a power of 2 as well.
 298          */
 299         BUG_ON(FEC_BLOCK_SIZE > PAGE_SIZE);
 300         /* 512 byte sector alignment */
 301         BUG_ON(((device_size - FEC_BLOCK_SIZE) % (1 << SECTOR_SHIFT)) != 0);
 302
 303         err = read_block_dev(&payload, bdev, (device_size -
 304                 FEC_BLOCK_SIZE) / (1 << SECTOR_SHIFT), FEC_BLOCK_SIZE);
 305         if (err) {
 306                 DMERR("Error while reading verity metadata");
 307                 goto error;
 308         }
 309
 310         BUG_ON(sizeof(struct fec_header) > PAGE_SIZE);
 311         memcpy(fec, page_address(payload.page_io[0]),
 312                         sizeof(*fec));
 313
 314         ecc->valid = true;
 315         if (validate_fec_header(fec, device_size - FEC_BLOCK_SIZE)) {
 316                 /* Try the backup header */
 317                 memcpy(fec, page_address(payload.page_io[0]) + FEC_BLOCK_SIZE
 318                         - sizeof(*fec) ,
 319                         sizeof(*fec));
 320                 if (validate_fec_header(fec, device_size -
 321                         sizeof(struct fec_header)))
 322                         ecc->valid = false;
 323         }
 324
 325         if (ecc->valid)
 326                 populate_fec_metadata(fec, ecc);
 327
 328         for (i = 0; i < payload.number_of_pages; i++)
 329                 __free_page(payload.page_io[i]);
 330         kfree(payload.page_io);
 331
 332 error:
 333         blkdev_put(bdev, FMODE_READ);
 334         return err;
 335 }
 336 static void find_metadata_offset(struct fec_header *fec,
 337                 struct block_device *bdev, u64 *metadata_offset)
 338 {
 339         u64 device_size;
 340
 341         device_size = i_size_read(bdev->bd_inode);
 342
 343         if (le32_to_cpu(fec->magic) == FEC_MAGIC)
 344                 *metadata_offset = le64_to_cpu(fec->inp_size) -
 345                                         VERITY_METADATA_SIZE;
 346         else
 347                 *metadata_offset = device_size - VERITY_METADATA_SIZE;
 348 }
 349
 350 static int find_size(dev_t dev, u64 *device_size)
 351 {
 352         struct block_device *bdev;
 353
 354         bdev = blkdev_get_by_dev(dev, FMODE_READ, NULL);
 355         if (IS_ERR_OR_NULL(bdev)) {
 356                 DMERR("blkdev_get_by_dev failed");
 357                 return PTR_ERR(bdev);
 358         }
 359
 360         *device_size = i_size_read(bdev->bd_inode);
 361         *device_size >>= SECTOR_SHIFT;
 362
 363         DMINFO("blkdev size in sectors: %llu", *device_size);
 364         blkdev_put(bdev, FMODE_READ);
 365         return 0;
 366 }
 367
 368 static int verify_header(struct android_metadata_header *header)
 369 {
 370         int retval = -EINVAL;
 371
 372         if (is_userdebug() && le32_to_cpu(header->magic_number) ==
 373                         VERITY_METADATA_MAGIC_DISABLE)
 374                 return VERITY_STATE_DISABLE;
 375
 376         if (!(le32_to_cpu(header->magic_number) ==
 377                         VERITY_METADATA_MAGIC_NUMBER) ||
 378                         (le32_to_cpu(header->magic_number) ==
 379                         VERITY_METADATA_MAGIC_DISABLE)) {
 380                 DMERR("Incorrect magic number");
 381                 return retval;
 382         }
 383
 384         if (le32_to_cpu(header->protocol_version) !=
 385                         VERITY_METADATA_VERSION) {
 386                 DMERR("Unsupported version %u",
 387                         le32_to_cpu(header->protocol_version));
 388                 return retval;
 389         }
 390
 391         return 0;
 392 }
 393
 394 static int extract_metadata(dev_t dev, struct fec_header *fec,
 395                                 struct android_metadata **metadata,
 396                                 bool *verity_enabled)
 397 {
 398         struct block_device *bdev;
 399         struct android_metadata_header *header;
 400         int i;
 401         u32 table_length, copy_length, offset;
 402         u64 metadata_offset;
 403         struct bio_read payload;
 404         int err = 0;
 405
 406         bdev = blkdev_get_by_dev(dev, FMODE_READ, NULL);
 407
 408         if (IS_ERR_OR_NULL(bdev)) {
 409                 DMERR("blkdev_get_by_dev failed");
 410                 return -ENODEV;
 411         }
 412
 413         find_metadata_offset(fec, bdev, &metadata_offset);
 414
 415         /* Verity metadata size is a power of 2 and PAGE_SIZE
 416          * is a power of 2 as well.
 417          * PAGE_SIZE is also a multiple of 512 bytes.
 418         */
 419         if (VERITY_METADATA_SIZE > PAGE_SIZE)
 420                 BUG_ON(VERITY_METADATA_SIZE % PAGE_SIZE != 0);
 421         /* 512 byte sector alignment */
 422         BUG_ON(metadata_offset % (1 << SECTOR_SHIFT) != 0);
 423
 424         err = read_block_dev(&payload, bdev, metadata_offset /
 425                 (1 << SECTOR_SHIFT), VERITY_METADATA_SIZE);
 426         if (err) {
 427                 DMERR("Error while reading verity metadata");
 428                 goto blkdev_release;
 429         }
 430
 431         header = kzalloc(sizeof(*header), GFP_KERNEL);
 432         if (!header) {
 433                 DMERR("kzalloc failed for header");
 434                 err = -ENOMEM;
 435                 goto free_payload;
 436         }
 437
 438         memcpy(header, page_address(payload.page_io[0]),
 439                 sizeof(*header));
 440
 441         DMINFO("bio magic_number:%u protocol_version:%d table_length:%u",
 442                 le32_to_cpu(header->magic_number),
 443                 le32_to_cpu(header->protocol_version),
 444                 le32_to_cpu(header->table_length));
 445
 446         err = verify_header(header);
 447
 448         if (err == VERITY_STATE_DISABLE) {
 449                 DMERR("Mounting root with verity disabled");
 450                 *verity_enabled = false;
 451                 /* we would still have to read the metadata to figure out
 452                  * the data blocks size. Or may be could map the entire
 453                  * partition similar to mounting the device.
 454                  *
 455                  * Reset error as well as the verity_enabled flag is changed.
 456                  */
 457                 err = 0;
 458         } else if (err)
 459                 goto free_header;
 460
 461         *metadata = kzalloc(sizeof(**metadata), GFP_KERNEL);
 462         if (!*metadata) {
 463                 DMERR("kzalloc for metadata failed");
 464                 err = -ENOMEM;
 465                 goto free_header;
 466         }
 467
 468         (*metadata)->header = header;
 469         table_length = le32_to_cpu(header->table_length);
 470
 471         if (table_length == 0 ||
 472                 table_length > (VERITY_METADATA_SIZE -
 473                         sizeof(struct android_metadata_header))) {
 474                 DMERR("table_length too long");
 475                 err = -EINVAL;
 476                 goto free_metadata;
 477         }
 478
 479         (*metadata)->verity_table = kzalloc(table_length + 1, GFP_KERNEL);
 480
 481         if (!(*metadata)->verity_table) {
 482                 DMERR("kzalloc verity_table failed");
 483                 err = -ENOMEM;
 484                 goto free_metadata;
 485         }
 486
 487         if (sizeof(struct android_metadata_header) +
 488                         table_length <= PAGE_SIZE) {
 489                 memcpy((*metadata)->verity_table,
 490                         page_address(payload.page_io[0])
 491                         + sizeof(struct android_metadata_header),
 492                         table_length);
 493         } else {
 494                 copy_length = PAGE_SIZE -
 495                         sizeof(struct android_metadata_header);
 496                 memcpy((*metadata)->verity_table,
 497                         page_address(payload.page_io[0])
 498                         + sizeof(struct android_metadata_header),
 499                         copy_length);
 500                 table_length -= copy_length;
 501                 offset = copy_length;
 502                 i = 1;
 503                 while (table_length != 0) {
 504                         if (table_length > PAGE_SIZE) {
 505                                 memcpy((*metadata)->verity_table + offset,
 506                                         page_address(payload.page_io[i]),
 507                                         PAGE_SIZE);
 508                                 offset += PAGE_SIZE;
 509                                 table_length -= PAGE_SIZE;
 510                         } else {
 511                                 memcpy((*metadata)->verity_table + offset,
 512                                         page_address(payload.page_io[i]),
 513                                         table_length);
 514                                 table_length = 0;
 515                         }
 516                         i++;
 517                 }
 518         }
 519         (*metadata)->verity_table[table_length] = '\0';
 520
 521         DMINFO("verity_table: %s", (*metadata)->verity_table);
 522         goto free_payload;
 523
 524 free_metadata:
 525         kfree(*metadata);
 526 free_header:
 527         kfree(header);
 528 free_payload:
 529         for (i = 0; i < payload.number_of_pages; i++)
 530                 if (payload.page_io[i])
 531                         __free_page(payload.page_io[i]);
 532         kfree(payload.page_io);
 533 blkdev_release:
 534         blkdev_put(bdev, FMODE_READ);
 535         return err;
 536 }
 537
 538 /* helper functions to extract properties from dts */
 539 const char *find_dt_value(const char *name)
 540 {
 541         struct device_node *firmware;
 542         const char *value;
 543
 544         firmware = of_find_node_by_path("/firmware/android");
 545         if (!firmware)
 546                 return NULL;
 547         value = of_get_property(firmware, name, NULL);
 548         of_node_put(firmware);
 549
 550         return value;
 551 }
 552
 553 static int verity_mode(void)
 554 {
 555         static const char enforcing[] = "enforcing";
 556         static const char verified_mode_prop[] = "veritymode";
 557         const char *value;
 558
 559         value = find_dt_value(verified_mode_prop);
 560         if (!value)
 561                 value = veritymode;
 562         if (!strncmp(value, enforcing, sizeof(enforcing) - 1))
 563                 return DM_VERITY_MODE_RESTART;
 564
 565         return DM_VERITY_MODE_EIO;
 566 }
 567
 568 static int verify_verity_signature(char *key_id,
 569                 struct android_metadata *metadata)
 570 {
 571         key_ref_t key_ref;
 572         struct key *key;
 573         struct public_key_signature *pks = NULL;
 574         int retval = -EINVAL;
 575
 576         key_ref = keyring_search(make_key_ref(system_trusted_keyring, 1),
 577                 &key_type_asymmetric, key_id);
 578
 579         if (IS_ERR(key_ref)) {
 580                 DMERR("keyring: key not found");
 581                 return -ENOKEY;
 582         }
 583
 584         key = key_ref_to_ptr(key_ref);
 585
 586         pks = table_make_digest(HASH_ALGO_SHA256,
 587                         (const void *)metadata->verity_table,
 588                         le32_to_cpu(metadata->header->table_length));
 589
 590         if (IS_ERR(pks)) {
 591                 DMERR("hashing failed");
 592                 goto error;
 593         }
 594
 595         retval = table_extract_mpi_array(pks, &metadata->header->signature[0],
 596                                 RSANUMBYTES);
 597         if (retval < 0) {
 598                 DMERR("Error extracting mpi %d", retval);
 599                 goto error;
 600         }
 601
 602         retval = verify_signature(key, pks);
 603         mpi_free(pks->rsa.s);
 604 error:
 605         kfree(pks);
 606         key_put(key);
 607
 608         return retval;
 609 }
 610
 611 static void handle_error(void)
 612 {
 613         int mode = verity_mode();
 614         if (mode == DM_VERITY_MODE_RESTART) {
 615                 DMERR("triggering restart");
 616                 kernel_restart("dm-verity device corrupted");
 617         } else {
 618                 DMERR("Mounting verity root failed");
 619         }
 620 }
 621
 622 static inline bool test_mult_overflow(sector_t a, u32 b)
 623 {
 624         sector_t r = (sector_t)~0ULL;
 625
 626         sector_div(r, b);
 627         return a > r;
 628 }
 629
 630 static int add_as_linear_device(struct dm_target *ti, char *dev)
 631 {
 632         /*Move to linear mapping defines*/
 633         char *linear_table_args[DM_LINEAR_ARGS] = {dev,
 634                                         DM_LINEAR_TARGET_OFFSET};
 635         int err = 0;
 636
 637         android_verity_target.dtr = dm_linear_dtr,
 638         android_verity_target.map = dm_linear_map,
 639         android_verity_target.status = dm_linear_status,
 640         android_verity_target.ioctl = dm_linear_ioctl,
 641         android_verity_target.merge = dm_linear_merge,
 642         android_verity_target.iterate_devices = dm_linear_iterate_devices,
 643         android_verity_target.io_hints = NULL;
 644
 645         err = dm_linear_ctr(ti, DM_LINEAR_ARGS, linear_table_args);
 646
 647         if (!err) {
 648                 DMINFO("Added android-verity as a linear target");
 649                 target_added = true;
 650         } else
 651                 DMERR("Failed to add android-verity as linear target");
 652
 653         return err;
 654 }
 655
 656 /*
 657  * Target parameters:
 658  *      <key id>        Key id of the public key in the system keyring.
 659  *                      Verity metadata's signature would be verified against
 660  *                      this. If the key id contains spaces, replace them
 661  *                      with '#'.
 662  *      <block device>  The block device for which dm-verity is being setup.
 663  */
 664 static int android_verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
 665 {
 666         dev_t uninitialized_var(dev);
 667         struct android_metadata *metadata = NULL;
 668         int err = 0, i, mode;
 669         char *key_id, *table_ptr, dummy, *target_device,
 670         *verity_table_args[VERITY_TABLE_ARGS + 2 + VERITY_TABLE_OPT_FEC_ARGS];
 671         /* One for specifying number of opt args and one for mode */
 672         sector_t data_sectors;
 673         u32 data_block_size;
 674         unsigned int no_of_args = VERITY_TABLE_ARGS + 2 + VERITY_TABLE_OPT_FEC_ARGS;
 675         struct fec_header uninitialized_var(fec);
 676         struct fec_ecc_metadata uninitialized_var(ecc);
 677         char buf[FEC_ARG_LENGTH], *buf_ptr;
 678         unsigned long long tmpll;
 679         u64 device_size;
 680
 681         if (argc == 1) {
 682                 /* Use the default keyid */
 683                 if (default_verity_key_id())
 684                         key_id = veritykeyid;
 685                 else if (!is_eng()) {
 686                         DMERR("veritykeyid= is not set");
 687                         handle_error();
 688                         return -EINVAL;
 689                 }
 690         } else if (argc == 2)
 691                 key_id = argv[1];
 692         else {
 693                 DMERR("Incorrect number of arguments");
 694                 handle_error();
 695                 return -EINVAL;
 696         }
 697
 698         target_device = argv[0];
 699
 700         dev = name_to_dev_t(target_device);
 701         if (!dev) {
 702                 DMERR("no dev found for %s", target_device);
 703                 handle_error();
 704                 return -EINVAL;
 705         }
 706
 707         if (is_eng()) {
 708                 err = find_size(dev, &device_size);
 709                 if (err) {
 710                         DMERR("error finding bdev size");
 711                         handle_error();
 712                         return err;
 713                 }
 714
 715                 ti->len = device_size;
 716                 err = add_as_linear_device(ti, target_device);
 717                 if (err) {
 718                         handle_error();
 719                         return err;
 720                 }
 721                 verity_enabled = false;
 722                 return 0;
 723         }
 724
 725         strreplace(key_id, '#', ' ');
 726
 727         DMINFO("key:%s dev:%s", key_id, target_device);
 728
 729         if (extract_fec_header(dev, &fec, &ecc)) {
 730                 DMERR("Error while extracting fec header");
 731                 handle_error();
 732                 return -EINVAL;
 733         }
 734
 735         err = extract_metadata(dev, &fec, &metadata, &verity_enabled);
 736
 737         if (err) {
 738                 DMERR("Error while extracting metadata");
 739                 handle_error();
 740                 goto free_metadata;
 741         }
 742
 743         if (verity_enabled) {
 744                 err = verify_verity_signature(key_id, metadata);
 745
 746                 if (err) {
 747                         DMERR("Signature verification failed");
 748                         handle_error();
 749                         goto free_metadata;
 750                 } else
 751                         DMINFO("Signature verification success");
 752         }
 753
 754         table_ptr = metadata->verity_table;
 755
 756         for (i = 0; i < VERITY_TABLE_ARGS; i++) {
 757                 verity_table_args[i] = strsep(&table_ptr, " ");
 758                 if (verity_table_args[i] == NULL)
 759                         break;
 760         }
 761
 762         if (i != VERITY_TABLE_ARGS) {
 763                 DMERR("Verity table not in the expected format");
 764                 err = -EINVAL;
 765                 handle_error();
 766                 goto free_metadata;
 767         }
 768
 769         if (sscanf(verity_table_args[5], "%llu%c", &tmpll, &dummy)
 770                                                         != 1) {
 771                 DMERR("Verity table not in the expected format");
 772                 handle_error();
 773                 err = -EINVAL;
 774                 goto free_metadata;
 775         }
 776
 777         if (tmpll > ULONG_MAX) {
 778                 DMERR("<num_data_blocks> too large. Forgot to turn on CONFIG_LBDAF?");
 779                 handle_error();
 780                 err = -EINVAL;
 781                 goto free_metadata;
 782         }
 783
 784         data_sectors = tmpll;
 785
 786         if (sscanf(verity_table_args[3], "%u%c", &data_block_size, &dummy)
 787                                                                 != 1) {
 788                 DMERR("Verity table not in the expected format");
 789                 handle_error();
 790                 err = -EINVAL;
 791                 goto free_metadata;
 792         }
 793
 794         if (test_mult_overflow(data_sectors, data_block_size >>
 795                                                         SECTOR_SHIFT)) {
 796                 DMERR("data_sectors too large");
 797                 handle_error();
 798                 err = -EOVERFLOW;
 799                 goto free_metadata;
 800         }
 801
 802         data_sectors *= data_block_size >> SECTOR_SHIFT;
 803         DMINFO("Data sectors %llu", (unsigned long long)data_sectors);
 804
 805         /* update target length */
 806         ti->len = data_sectors;
 807
 808         /* Setup linear target and free */
 809         if (!verity_enabled) {
 810                 err = add_as_linear_device(ti, target_device);
 811                 goto free_metadata;
 812         }
 813
 814         /*substitute data_dev and hash_dev*/
 815         verity_table_args[1] = target_device;
 816         verity_table_args[2] = target_device;
 817
 818         mode = verity_mode();
 819
 820         if (ecc.valid && IS_BUILTIN(CONFIG_DM_VERITY_FEC)) {
 821                 if (mode) {
 822                         err = snprintf(buf, FEC_ARG_LENGTH,
 823                                 "%u %s " VERITY_TABLE_OPT_FEC_FORMAT,
 824                                 1 + VERITY_TABLE_OPT_FEC_ARGS,
 825                                 mode == DM_VERITY_MODE_RESTART ?
 826                                         VERITY_TABLE_OPT_RESTART :
 827                                         VERITY_TABLE_OPT_LOGGING,
 828                                 target_device,
 829                                 ecc.start / FEC_BLOCK_SIZE, ecc.blocks,
 830                                 ecc.roots);
 831                 } else {
 832                         err = snprintf(buf, FEC_ARG_LENGTH,
 833                                 "%u " VERITY_TABLE_OPT_FEC_FORMAT,
 834                                 VERITY_TABLE_OPT_FEC_ARGS, target_device,
 835                                 ecc.start / FEC_BLOCK_SIZE, ecc.blocks,
 836                                 ecc.roots);
 837                 }
 838         } else if (mode) {
 839                 err = snprintf(buf, FEC_ARG_LENGTH,
 840                         "2 " VERITY_TABLE_OPT_IGNZERO " %s",
 841                         mode == DM_VERITY_MODE_RESTART ?
 842                         VERITY_TABLE_OPT_RESTART : VERITY_TABLE_OPT_LOGGING);
 843         } else {
 844                 err = snprintf(buf, FEC_ARG_LENGTH, "1 %s",
 845                                  "ignore_zero_blocks");
 846         }
 847
 848         if (err < 0 || err >= FEC_ARG_LENGTH)
 849                 goto free_metadata;
 850
 851         buf_ptr = buf;
 852
 853         for (i = VERITY_TABLE_ARGS; i < (VERITY_TABLE_ARGS +
 854                 VERITY_TABLE_OPT_FEC_ARGS + 2); i++) {
 855                 verity_table_args[i] = strsep(&buf_ptr, " ");
 856                 if (verity_table_args[i] == NULL) {
 857                         no_of_args = i;
 858                         break;
 859                 }
 860         }
 861
 862         err = verity_ctr(ti, no_of_args, verity_table_args);
 863
 864         if (err)
 865                 DMERR("android-verity failed to mount as verity target");
 866         else {
 867                 target_added = true;
 868                 DMINFO("android-verity mounted as verity target");
 869         }
 870
 871 free_metadata:
 872         if (metadata) {
 873                 kfree(metadata->header);
 874                 kfree(metadata->verity_table);
 875         }
 876         kfree(metadata);
 877         return err;
 878 }
 879
 880 static int __init dm_android_verity_init(void)
 881 {
 882         int r;
 883         struct dentry *file;
 884
 885         r = dm_register_target(&android_verity_target);
 886         if (r < 0)
 887                 DMERR("register failed %d", r);
 888
 889         /* Tracks the status of the last added target */
 890         debug_dir = debugfs_create_dir("android_verity", NULL);
 891
 892         if (IS_ERR_OR_NULL(debug_dir)) {
 893                 DMERR("Cannot create android_verity debugfs directory: %ld",
 894                         PTR_ERR(debug_dir));
 895                 goto end;
 896         }
 897
 898         file = debugfs_create_bool("target_added", S_IRUGO, debug_dir,
 899                                 (u32 *)&target_added);
 900
 901         if (IS_ERR_OR_NULL(file)) {
 902                 DMERR("Cannot create android_verity debugfs directory: %ld",
 903                         PTR_ERR(debug_dir));
 904                 debugfs_remove_recursive(debug_dir);
 905                 goto end;
 906         }
 907
 908         file = debugfs_create_bool("verity_enabled", S_IRUGO, debug_dir,
 909                                 (u32 *)&verity_enabled);
 910
 911         if (IS_ERR_OR_NULL(file)) {
 912                 DMERR("Cannot create android_verity debugfs directory: %ld",
 913                         PTR_ERR(debug_dir));
 914                 debugfs_remove_recursive(debug_dir);
 915         }
 916
 917 end:
 918         return r;
 919 }
 920
 921 static void __exit dm_android_verity_exit(void)
 922 {
 923         if (!IS_ERR_OR_NULL(debug_dir))
 924                 debugfs_remove_recursive(debug_dir);
 925
 926         dm_unregister_target(&android_verity_target);
 927 }
 928
 929 module_init(dm_android_verity_init);
 930 module_exit(dm_android_verity_exit);