drivers/virt/coco/sev-guest/sev-guest.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AMD Secure Encrypted Virtualization (SEV) guest driver interface
   4  *
   5  * Copyright (C) 2021 Advanced Micro Devices, Inc.
   6  *
   7  * Author: Brijesh Singh <brijesh.singh@amd.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/types.h>
  13 #include <linux/mutex.h>
  14 #include <linux/io.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/miscdevice.h>
  17 #include <linux/set_memory.h>
  18 #include <linux/fs.h>
  19 #include <crypto/aead.h>
  20 #include <linux/scatterlist.h>
  21 #include <linux/psp-sev.h>
  22 #include <uapi/linux/sev-guest.h>
  23 #include <uapi/linux/psp-sev.h>
  24
  25 #include <asm/svm.h>
  26 #include <asm/sev.h>
  27
  28 #include "sev-guest.h"
  29
  30 #define DEVICE_NAME     "sev-guest"
  31 #define AAD_LEN         48
  32 #define MSG_HDR_VER     1
  33
  34 struct snp_guest_crypto {
  35         struct crypto_aead *tfm;
  36         u8 *iv, *authtag;
  37         int iv_len, a_len;
  38 };
  39
  40 struct snp_guest_dev {
  41         struct device *dev;
  42         struct miscdevice misc;
  43
  44         void *certs_data;
  45         struct snp_guest_crypto *crypto;
  46         struct snp_guest_msg *request, *response;
  47         struct snp_secrets_page_layout *layout;
  48         struct snp_req_data input;
  49         u32 *os_area_msg_seqno;
  50         u8 *vmpck;
  51 };
  52
  53 static u32 vmpck_id;
  54 module_param(vmpck_id, uint, 0444);
  55 MODULE_PARM_DESC(vmpck_id, "The VMPCK ID to use when communicating with the PSP.");
  56
  57 /* Mutex to serialize the shared buffer access and command handling. */
  58 static DEFINE_MUTEX(snp_cmd_mutex);
  59
  60 static bool is_vmpck_empty(struct snp_guest_dev *snp_dev)
  61 {
  62         char zero_key[VMPCK_KEY_LEN] = {0};
  63
  64         if (snp_dev->vmpck)
  65                 return !memcmp(snp_dev->vmpck, zero_key, VMPCK_KEY_LEN);
  66
  67         return true;
  68 }
  69
  70 /*
  71  * If an error is received from the host or AMD Secure Processor (ASP) there
  72  * are two options. Either retry the exact same encrypted request or discontinue
  73  * using the VMPCK.
  74  *
  75  * This is because in the current encryption scheme GHCB v2 uses AES-GCM to
  76  * encrypt the requests. The IV for this scheme is the sequence number. GCM
  77  * cannot tolerate IV reuse.
  78  *
  79  * The ASP FW v1.51 only increments the sequence numbers on a successful
  80  * guest<->ASP back and forth and only accepts messages at its exact sequence
  81  * number.
  82  *
  83  * So if the sequence number were to be reused the encryption scheme is
  84  * vulnerable. If the sequence number were incremented for a fresh IV the ASP
  85  * will reject the request.
  86  */
  87 static void snp_disable_vmpck(struct snp_guest_dev *snp_dev)
  88 {
  89         dev_alert(snp_dev->dev, "Disabling vmpck_id %d to prevent IV reuse.\n",
  90                   vmpck_id);
  91         memzero_explicit(snp_dev->vmpck, VMPCK_KEY_LEN);
  92         snp_dev->vmpck = NULL;
  93 }
  94
  95 static inline u64 __snp_get_msg_seqno(struct snp_guest_dev *snp_dev)
  96 {
  97         u64 count;
  98
  99         lockdep_assert_held(&snp_cmd_mutex);
 100
 101         /* Read the current message sequence counter from secrets pages */
 102         count = *snp_dev->os_area_msg_seqno;
 103
 104         return count + 1;
 105 }
 106
 107 /* Return a non-zero on success */
 108 static u64 snp_get_msg_seqno(struct snp_guest_dev *snp_dev)
 109 {
 110         u64 count = __snp_get_msg_seqno(snp_dev);
 111
 112         /*
 113          * The message sequence counter for the SNP guest request is a  64-bit
 114          * value but the version 2 of GHCB specification defines a 32-bit storage
 115          * for it. If the counter exceeds the 32-bit value then return zero.
 116          * The caller should check the return value, but if the caller happens to
 117          * not check the value and use it, then the firmware treats zero as an
 118          * invalid number and will fail the  message request.
 119          */
 120         if (count >= UINT_MAX) {
 121                 dev_err(snp_dev->dev, "request message sequence counter overflow\n");
 122                 return 0;
 123         }
 124
 125         return count;
 126 }
 127
 128 static void snp_inc_msg_seqno(struct snp_guest_dev *snp_dev)
 129 {
 130         /*
 131          * The counter is also incremented by the PSP, so increment it by 2
 132          * and save in secrets page.
 133          */
 134         *snp_dev->os_area_msg_seqno += 2;
 135 }
 136
 137 static inline struct snp_guest_dev *to_snp_dev(struct file *file)
 138 {
 139         struct miscdevice *dev = file->private_data;
 140
 141         return container_of(dev, struct snp_guest_dev, misc);
 142 }
 143
 144 static struct snp_guest_crypto *init_crypto(struct snp_guest_dev *snp_dev, u8 *key, size_t keylen)
 145 {
 146         struct snp_guest_crypto *crypto;
 147
 148         crypto = kzalloc(sizeof(*crypto), GFP_KERNEL_ACCOUNT);
 149         if (!crypto)
 150                 return NULL;
 151
 152         crypto->tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
 153         if (IS_ERR(crypto->tfm))
 154                 goto e_free;
 155
 156         if (crypto_aead_setkey(crypto->tfm, key, keylen))
 157                 goto e_free_crypto;
 158
 159         crypto->iv_len = crypto_aead_ivsize(crypto->tfm);
 160         crypto->iv = kmalloc(crypto->iv_len, GFP_KERNEL_ACCOUNT);
 161         if (!crypto->iv)
 162                 goto e_free_crypto;
 163
 164         if (crypto_aead_authsize(crypto->tfm) > MAX_AUTHTAG_LEN) {
 165                 if (crypto_aead_setauthsize(crypto->tfm, MAX_AUTHTAG_LEN)) {
 166                         dev_err(snp_dev->dev, "failed to set authsize to %d\n", MAX_AUTHTAG_LEN);
 167                         goto e_free_iv;
 168                 }
 169         }
 170
 171         crypto->a_len = crypto_aead_authsize(crypto->tfm);
 172         crypto->authtag = kmalloc(crypto->a_len, GFP_KERNEL_ACCOUNT);
 173         if (!crypto->authtag)
 174                 goto e_free_auth;
 175
 176         return crypto;
 177
 178 e_free_auth:
 179         kfree(crypto->authtag);
 180 e_free_iv:
 181         kfree(crypto->iv);
 182 e_free_crypto:
 183         crypto_free_aead(crypto->tfm);
 184 e_free:
 185         kfree(crypto);
 186
 187         return NULL;
 188 }
 189
 190 static void deinit_crypto(struct snp_guest_crypto *crypto)
 191 {
 192         crypto_free_aead(crypto->tfm);
 193         kfree(crypto->iv);
 194         kfree(crypto->authtag);
 195         kfree(crypto);
 196 }
 197
 198 static int enc_dec_message(struct snp_guest_crypto *crypto, struct snp_guest_msg *msg,
 199                            u8 *src_buf, u8 *dst_buf, size_t len, bool enc)
 200 {
 201         struct snp_guest_msg_hdr *hdr = &msg->hdr;
 202         struct scatterlist src[3], dst[3];
 203         DECLARE_CRYPTO_WAIT(wait);
 204         struct aead_request *req;
 205         int ret;
 206
 207         req = aead_request_alloc(crypto->tfm, GFP_KERNEL);
 208         if (!req)
 209                 return -ENOMEM;
 210
 211         /*
 212          * AEAD memory operations:
 213          * +------ AAD -------+------- DATA -----+---- AUTHTAG----+
 214          * |  msg header      |  plaintext       |  hdr->authtag  |
 215          * | bytes 30h - 5Fh  |    or            |                |
 216          * |                  |   cipher         |                |
 217          * +------------------+------------------+----------------+
 218          */
 219         sg_init_table(src, 3);
 220         sg_set_buf(&src[0], &hdr->algo, AAD_LEN);
 221         sg_set_buf(&src[1], src_buf, hdr->msg_sz);
 222         sg_set_buf(&src[2], hdr->authtag, crypto->a_len);
 223
 224         sg_init_table(dst, 3);
 225         sg_set_buf(&dst[0], &hdr->algo, AAD_LEN);
 226         sg_set_buf(&dst[1], dst_buf, hdr->msg_sz);
 227         sg_set_buf(&dst[2], hdr->authtag, crypto->a_len);
 228
 229         aead_request_set_ad(req, AAD_LEN);
 230         aead_request_set_tfm(req, crypto->tfm);
 231         aead_request_set_callback(req, 0, crypto_req_done, &wait);
 232
 233         aead_request_set_crypt(req, src, dst, len, crypto->iv);
 234         ret = crypto_wait_req(enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req), &wait);
 235
 236         aead_request_free(req);
 237         return ret;
 238 }
 239
 240 static int __enc_payload(struct snp_guest_dev *snp_dev, struct snp_guest_msg *msg,
 241                          void *plaintext, size_t len)
 242 {
 243         struct snp_guest_crypto *crypto = snp_dev->crypto;
 244         struct snp_guest_msg_hdr *hdr = &msg->hdr;
 245
 246         memset(crypto->iv, 0, crypto->iv_len);
 247         memcpy(crypto->iv, &hdr->msg_seqno, sizeof(hdr->msg_seqno));
 248
 249         return enc_dec_message(crypto, msg, plaintext, msg->payload, len, true);
 250 }
 251
 252 static int dec_payload(struct snp_guest_dev *snp_dev, struct snp_guest_msg *msg,
 253                        void *plaintext, size_t len)
 254 {
 255         struct snp_guest_crypto *crypto = snp_dev->crypto;
 256         struct snp_guest_msg_hdr *hdr = &msg->hdr;
 257
 258         /* Build IV with response buffer sequence number */
 259         memset(crypto->iv, 0, crypto->iv_len);
 260         memcpy(crypto->iv, &hdr->msg_seqno, sizeof(hdr->msg_seqno));
 261
 262         return enc_dec_message(crypto, msg, msg->payload, plaintext, len, false);
 263 }
 264
 265 static int verify_and_dec_payload(struct snp_guest_dev *snp_dev, void *payload, u32 sz)
 266 {
 267         struct snp_guest_crypto *crypto = snp_dev->crypto;
 268         struct snp_guest_msg *resp = snp_dev->response;
 269         struct snp_guest_msg *req = snp_dev->request;
 270         struct snp_guest_msg_hdr *req_hdr = &req->hdr;
 271         struct snp_guest_msg_hdr *resp_hdr = &resp->hdr;
 272
 273         dev_dbg(snp_dev->dev, "response [seqno %lld type %d version %d sz %d]\n",
 274                 resp_hdr->msg_seqno, resp_hdr->msg_type, resp_hdr->msg_version, resp_hdr->msg_sz);
 275
 276         /* Verify that the sequence counter is incremented by 1 */
 277         if (unlikely(resp_hdr->msg_seqno != (req_hdr->msg_seqno + 1)))
 278                 return -EBADMSG;
 279
 280         /* Verify response message type and version number. */
 281         if (resp_hdr->msg_type != (req_hdr->msg_type + 1) ||
 282             resp_hdr->msg_version != req_hdr->msg_version)
 283                 return -EBADMSG;
 284
 285         /*
 286          * If the message size is greater than our buffer length then return
 287          * an error.
 288          */
 289         if (unlikely((resp_hdr->msg_sz + crypto->a_len) > sz))
 290                 return -EBADMSG;
 291
 292         /* Decrypt the payload */
 293         return dec_payload(snp_dev, resp, payload, resp_hdr->msg_sz + crypto->a_len);
 294 }
 295
 296 static int enc_payload(struct snp_guest_dev *snp_dev, u64 seqno, int version, u8 type,
 297                         void *payload, size_t sz)
 298 {
 299         struct snp_guest_msg *req = snp_dev->request;
 300         struct snp_guest_msg_hdr *hdr = &req->hdr;
 301
 302         memset(req, 0, sizeof(*req));
 303
 304         hdr->algo = SNP_AEAD_AES_256_GCM;
 305         hdr->hdr_version = MSG_HDR_VER;
 306         hdr->hdr_sz = sizeof(*hdr);
 307         hdr->msg_type = type;
 308         hdr->msg_version = version;
 309         hdr->msg_seqno = seqno;
 310         hdr->msg_vmpck = vmpck_id;
 311         hdr->msg_sz = sz;
 312
 313         /* Verify the sequence number is non-zero */
 314         if (!hdr->msg_seqno)
 315                 return -ENOSR;
 316
 317         dev_dbg(snp_dev->dev, "request [seqno %lld type %d version %d sz %d]\n",
 318                 hdr->msg_seqno, hdr->msg_type, hdr->msg_version, hdr->msg_sz);
 319
 320         return __enc_payload(snp_dev, req, payload, sz);
 321 }
 322
 323 static int handle_guest_request(struct snp_guest_dev *snp_dev, u64 exit_code, int msg_ver,
 324                                 u8 type, void *req_buf, size_t req_sz, void *resp_buf,
 325                                 u32 resp_sz, __u64 *fw_err)
 326 {
 327         unsigned long err;
 328         u64 seqno;
 329         int rc;
 330
 331         /* Get message sequence and verify that its a non-zero */
 332         seqno = snp_get_msg_seqno(snp_dev);
 333         if (!seqno)
 334                 return -EIO;
 335
 336         memset(snp_dev->response, 0, sizeof(struct snp_guest_msg));
 337
 338         /* Encrypt the userspace provided payload */
 339         rc = enc_payload(snp_dev, seqno, msg_ver, type, req_buf, req_sz);
 340         if (rc)
 341                 return rc;
 342
 343         /*
 344          * Call firmware to process the request. In this function the encrypted
 345          * message enters shared memory with the host. So after this call the
 346          * sequence number must be incremented or the VMPCK must be deleted to
 347          * prevent reuse of the IV.
 348          */
 349         rc = snp_issue_guest_request(exit_code, &snp_dev->input, &err);
 350
 351         /*
 352          * If the extended guest request fails due to having too small of a
 353          * certificate data buffer, retry the same guest request without the
 354          * extended data request in order to increment the sequence number
 355          * and thus avoid IV reuse.
 356          */
 357         if (exit_code == SVM_VMGEXIT_EXT_GUEST_REQUEST &&
 358             err == SNP_GUEST_REQ_INVALID_LEN) {
 359                 const unsigned int certs_npages = snp_dev->input.data_npages;
 360
 361                 exit_code = SVM_VMGEXIT_GUEST_REQUEST;
 362
 363                 /*
 364                  * If this call to the firmware succeeds, the sequence number can
 365                  * be incremented allowing for continued use of the VMPCK. If
 366                  * there is an error reflected in the return value, this value
 367                  * is checked further down and the result will be the deletion
 368                  * of the VMPCK and the error code being propagated back to the
 369                  * user as an ioctl() return code.
 370                  */
 371                 rc = snp_issue_guest_request(exit_code, &snp_dev->input, &err);
 372
 373                 /*
 374                  * Override the error to inform callers the given extended
 375                  * request buffer size was too small and give the caller the
 376                  * required buffer size.
 377                  */
 378                 err = SNP_GUEST_REQ_INVALID_LEN;
 379                 snp_dev->input.data_npages = certs_npages;
 380         }
 381
 382         if (fw_err)
 383                 *fw_err = err;
 384
 385         if (rc) {
 386                 dev_alert(snp_dev->dev,
 387                           "Detected error from ASP request. rc: %d, fw_err: %llu\n",
 388                           rc, *fw_err);
 389                 goto disable_vmpck;
 390         }
 391
 392         rc = verify_and_dec_payload(snp_dev, resp_buf, resp_sz);
 393         if (rc) {
 394                 dev_alert(snp_dev->dev,
 395                           "Detected unexpected decode failure from ASP. rc: %d\n",
 396                           rc);
 397                 goto disable_vmpck;
 398         }
 399
 400         /* Increment to new message sequence after payload decryption was successful. */
 401         snp_inc_msg_seqno(snp_dev);
 402
 403         return 0;
 404
 405 disable_vmpck:
 406         snp_disable_vmpck(snp_dev);
 407         return rc;
 408 }
 409
 410 static int get_report(struct snp_guest_dev *snp_dev, struct snp_guest_request_ioctl *arg)
 411 {
 412         struct snp_guest_crypto *crypto = snp_dev->crypto;
 413         struct snp_report_resp *resp;
 414         struct snp_report_req req;
 415         int rc, resp_len;
 416
 417         lockdep_assert_held(&snp_cmd_mutex);
 418
 419         if (!arg->req_data || !arg->resp_data)
 420                 return -EINVAL;
 421
 422         if (copy_from_user(&req, (void __user *)arg->req_data, sizeof(req)))
 423                 return -EFAULT;
 424
 425         /*
 426          * The intermediate response buffer is used while decrypting the
 427          * response payload. Make sure that it has enough space to cover the
 428          * authtag.
 429          */
 430         resp_len = sizeof(resp->data) + crypto->a_len;
 431         resp = kzalloc(resp_len, GFP_KERNEL_ACCOUNT);
 432         if (!resp)
 433                 return -ENOMEM;
 434
 435         rc = handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg->msg_version,
 436                                   SNP_MSG_REPORT_REQ, &req, sizeof(req), resp->data,
 437                                   resp_len, &arg->fw_err);
 438         if (rc)
 439                 goto e_free;
 440
 441         if (copy_to_user((void __user *)arg->resp_data, resp, sizeof(*resp)))
 442                 rc = -EFAULT;
 443
 444 e_free:
 445         kfree(resp);
 446         return rc;
 447 }
 448
 449 static int get_derived_key(struct snp_guest_dev *snp_dev, struct snp_guest_request_ioctl *arg)
 450 {
 451         struct snp_guest_crypto *crypto = snp_dev->crypto;
 452         struct snp_derived_key_resp resp = {0};
 453         struct snp_derived_key_req req;
 454         int rc, resp_len;
 455         /* Response data is 64 bytes and max authsize for GCM is 16 bytes. */
 456         u8 buf[64 + 16];
 457
 458         lockdep_assert_held(&snp_cmd_mutex);
 459
 460         if (!arg->req_data || !arg->resp_data)
 461                 return -EINVAL;
 462
 463         /*
 464          * The intermediate response buffer is used while decrypting the
 465          * response payload. Make sure that it has enough space to cover the
 466          * authtag.
 467          */
 468         resp_len = sizeof(resp.data) + crypto->a_len;
 469         if (sizeof(buf) < resp_len)
 470                 return -ENOMEM;
 471
 472         if (copy_from_user(&req, (void __user *)arg->req_data, sizeof(req)))
 473                 return -EFAULT;
 474
 475         rc = handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg->msg_version,
 476                                   SNP_MSG_KEY_REQ, &req, sizeof(req), buf, resp_len,
 477                                   &arg->fw_err);
 478         if (rc)
 479                 return rc;
 480
 481         memcpy(resp.data, buf, sizeof(resp.data));
 482         if (copy_to_user((void __user *)arg->resp_data, &resp, sizeof(resp)))
 483                 rc = -EFAULT;
 484
 485         /* The response buffer contains the sensitive data, explicitly clear it. */
 486         memzero_explicit(buf, sizeof(buf));
 487         memzero_explicit(&resp, sizeof(resp));
 488         return rc;
 489 }
 490
 491 static int get_ext_report(struct snp_guest_dev *snp_dev, struct snp_guest_request_ioctl *arg)
 492 {
 493         struct snp_guest_crypto *crypto = snp_dev->crypto;
 494         struct snp_ext_report_req req;
 495         struct snp_report_resp *resp;
 496         int ret, npages = 0, resp_len;
 497
 498         lockdep_assert_held(&snp_cmd_mutex);
 499
 500         if (!arg->req_data || !arg->resp_data)
 501                 return -EINVAL;
 502
 503         if (copy_from_user(&req, (void __user *)arg->req_data, sizeof(req)))
 504                 return -EFAULT;
 505
 506         /* userspace does not want certificate data */
 507         if (!req.certs_len || !req.certs_address)
 508                 goto cmd;
 509
 510         if (req.certs_len > SEV_FW_BLOB_MAX_SIZE ||
 511             !IS_ALIGNED(req.certs_len, PAGE_SIZE))
 512                 return -EINVAL;
 513
 514         if (!access_ok((const void __user *)req.certs_address, req.certs_len))
 515                 return -EFAULT;
 516
 517         /*
 518          * Initialize the intermediate buffer with all zeros. This buffer
 519          * is used in the guest request message to get the certs blob from
 520          * the host. If host does not supply any certs in it, then copy
 521          * zeros to indicate that certificate data was not provided.
 522          */
 523         memset(snp_dev->certs_data, 0, req.certs_len);
 524         npages = req.certs_len >> PAGE_SHIFT;
 525 cmd:
 526         /*
 527          * The intermediate response buffer is used while decrypting the
 528          * response payload. Make sure that it has enough space to cover the
 529          * authtag.
 530          */
 531         resp_len = sizeof(resp->data) + crypto->a_len;
 532         resp = kzalloc(resp_len, GFP_KERNEL_ACCOUNT);
 533         if (!resp)
 534                 return -ENOMEM;
 535
 536         snp_dev->input.data_npages = npages;
 537         ret = handle_guest_request(snp_dev, SVM_VMGEXIT_EXT_GUEST_REQUEST, arg->msg_version,
 538                                    SNP_MSG_REPORT_REQ, &req.data,
 539                                    sizeof(req.data), resp->data, resp_len, &arg->fw_err);
 540
 541         /* If certs length is invalid then copy the returned length */
 542         if (arg->fw_err == SNP_GUEST_REQ_INVALID_LEN) {
 543                 req.certs_len = snp_dev->input.data_npages << PAGE_SHIFT;
 544
 545                 if (copy_to_user((void __user *)arg->req_data, &req, sizeof(req)))
 546                         ret = -EFAULT;
 547         }
 548
 549         if (ret)
 550                 goto e_free;
 551
 552         if (npages &&
 553             copy_to_user((void __user *)req.certs_address, snp_dev->certs_data,
 554                          req.certs_len)) {
 555                 ret = -EFAULT;
 556                 goto e_free;
 557         }
 558
 559         if (copy_to_user((void __user *)arg->resp_data, resp, sizeof(*resp)))
 560                 ret = -EFAULT;
 561
 562 e_free:
 563         kfree(resp);
 564         return ret;
 565 }
 566
 567 static long snp_guest_ioctl(struct file *file, unsigned int ioctl, unsigned long arg)
 568 {
 569         struct snp_guest_dev *snp_dev = to_snp_dev(file);
 570         void __user *argp = (void __user *)arg;
 571         struct snp_guest_request_ioctl input;
 572         int ret = -ENOTTY;
 573
 574         if (copy_from_user(&input, argp, sizeof(input)))
 575                 return -EFAULT;
 576
 577         input.fw_err = 0xff;
 578
 579         /* Message version must be non-zero */
 580         if (!input.msg_version)
 581                 return -EINVAL;
 582
 583         mutex_lock(&snp_cmd_mutex);
 584
 585         /* Check if the VMPCK is not empty */
 586         if (is_vmpck_empty(snp_dev)) {
 587                 dev_err_ratelimited(snp_dev->dev, "VMPCK is disabled\n");
 588                 mutex_unlock(&snp_cmd_mutex);
 589                 return -ENOTTY;
 590         }
 591
 592         switch (ioctl) {
 593         case SNP_GET_REPORT:
 594                 ret = get_report(snp_dev, &input);
 595                 break;
 596         case SNP_GET_DERIVED_KEY:
 597                 ret = get_derived_key(snp_dev, &input);
 598                 break;
 599         case SNP_GET_EXT_REPORT:
 600                 ret = get_ext_report(snp_dev, &input);
 601                 break;
 602         default:
 603                 break;
 604         }
 605
 606         mutex_unlock(&snp_cmd_mutex);
 607
 608         if (input.fw_err && copy_to_user(argp, &input, sizeof(input)))
 609                 return -EFAULT;
 610
 611         return ret;
 612 }
 613
 614 static void free_shared_pages(void *buf, size_t sz)
 615 {
 616         unsigned int npages = PAGE_ALIGN(sz) >> PAGE_SHIFT;
 617         int ret;
 618
 619         if (!buf)
 620                 return;
 621
 622         ret = set_memory_encrypted((unsigned long)buf, npages);
 623         if (ret) {
 624                 WARN_ONCE(ret, "failed to restore encryption mask (leak it)\n");
 625                 return;
 626         }
 627
 628         __free_pages(virt_to_page(buf), get_order(sz));
 629 }
 630
 631 static void *alloc_shared_pages(struct device *dev, size_t sz)
 632 {
 633         unsigned int npages = PAGE_ALIGN(sz) >> PAGE_SHIFT;
 634         struct page *page;
 635         int ret;
 636
 637         page = alloc_pages(GFP_KERNEL_ACCOUNT, get_order(sz));
 638         if (!page)
 639                 return NULL;
 640
 641         ret = set_memory_decrypted((unsigned long)page_address(page), npages);
 642         if (ret) {
 643                 dev_err(dev, "failed to mark page shared, ret=%d\n", ret);
 644                 __free_pages(page, get_order(sz));
 645                 return NULL;
 646         }
 647
 648         return page_address(page);
 649 }
 650
 651 static const struct file_operations snp_guest_fops = {
 652         .owner  = THIS_MODULE,
 653         .unlocked_ioctl = snp_guest_ioctl,
 654 };
 655
 656 static u8 *get_vmpck(int id, struct snp_secrets_page_layout *layout, u32 **seqno)
 657 {
 658         u8 *key = NULL;
 659
 660         switch (id) {
 661         case 0:
 662                 *seqno = &layout->os_area.msg_seqno_0;
 663                 key = layout->vmpck0;
 664                 break;
 665         case 1:
 666                 *seqno = &layout->os_area.msg_seqno_1;
 667                 key = layout->vmpck1;
 668                 break;
 669         case 2:
 670                 *seqno = &layout->os_area.msg_seqno_2;
 671                 key = layout->vmpck2;
 672                 break;
 673         case 3:
 674                 *seqno = &layout->os_area.msg_seqno_3;
 675                 key = layout->vmpck3;
 676                 break;
 677         default:
 678                 break;
 679         }
 680
 681         return key;
 682 }
 683
 684 static int __init sev_guest_probe(struct platform_device *pdev)
 685 {
 686         struct snp_secrets_page_layout *layout;
 687         struct sev_guest_platform_data *data;
 688         struct device *dev = &pdev->dev;
 689         struct snp_guest_dev *snp_dev;
 690         struct miscdevice *misc;
 691         void __iomem *mapping;
 692         int ret;
 693
 694         if (!dev->platform_data)
 695                 return -ENODEV;
 696
 697         data = (struct sev_guest_platform_data *)dev->platform_data;
 698         mapping = ioremap_encrypted(data->secrets_gpa, PAGE_SIZE);
 699         if (!mapping)
 700                 return -ENODEV;
 701
 702         layout = (__force void *)mapping;
 703
 704         ret = -ENOMEM;
 705         snp_dev = devm_kzalloc(&pdev->dev, sizeof(struct snp_guest_dev), GFP_KERNEL);
 706         if (!snp_dev)
 707                 goto e_unmap;
 708
 709         ret = -EINVAL;
 710         snp_dev->vmpck = get_vmpck(vmpck_id, layout, &snp_dev->os_area_msg_seqno);
 711         if (!snp_dev->vmpck) {
 712                 dev_err(dev, "invalid vmpck id %d\n", vmpck_id);
 713                 goto e_unmap;
 714         }
 715
 716         /* Verify that VMPCK is not zero. */
 717         if (is_vmpck_empty(snp_dev)) {
 718                 dev_err(dev, "vmpck id %d is null\n", vmpck_id);
 719                 goto e_unmap;
 720         }
 721
 722         platform_set_drvdata(pdev, snp_dev);
 723         snp_dev->dev = dev;
 724         snp_dev->layout = layout;
 725
 726         /* Allocate the shared page used for the request and response message. */
 727         snp_dev->request = alloc_shared_pages(dev, sizeof(struct snp_guest_msg));
 728         if (!snp_dev->request)
 729                 goto e_unmap;
 730
 731         snp_dev->response = alloc_shared_pages(dev, sizeof(struct snp_guest_msg));
 732         if (!snp_dev->response)
 733                 goto e_free_request;
 734
 735         snp_dev->certs_data = alloc_shared_pages(dev, SEV_FW_BLOB_MAX_SIZE);
 736         if (!snp_dev->certs_data)
 737                 goto e_free_response;
 738
 739         ret = -EIO;
 740         snp_dev->crypto = init_crypto(snp_dev, snp_dev->vmpck, VMPCK_KEY_LEN);
 741         if (!snp_dev->crypto)
 742                 goto e_free_cert_data;
 743
 744         misc = &snp_dev->misc;
 745         misc->minor = MISC_DYNAMIC_MINOR;
 746         misc->name = DEVICE_NAME;
 747         misc->fops = &snp_guest_fops;
 748
 749         /* initial the input address for guest request */
 750         snp_dev->input.req_gpa = __pa(snp_dev->request);
 751         snp_dev->input.resp_gpa = __pa(snp_dev->response);
 752         snp_dev->input.data_gpa = __pa(snp_dev->certs_data);
 753
 754         ret =  misc_register(misc);
 755         if (ret)
 756                 goto e_free_cert_data;
 757
 758         dev_info(dev, "Initialized SEV guest driver (using vmpck_id %d)\n", vmpck_id);
 759         return 0;
 760
 761 e_free_cert_data:
 762         free_shared_pages(snp_dev->certs_data, SEV_FW_BLOB_MAX_SIZE);
 763 e_free_response:
 764         free_shared_pages(snp_dev->response, sizeof(struct snp_guest_msg));
 765 e_free_request:
 766         free_shared_pages(snp_dev->request, sizeof(struct snp_guest_msg));
 767 e_unmap:
 768         iounmap(mapping);
 769         return ret;
 770 }
 771
 772 static int __exit sev_guest_remove(struct platform_device *pdev)
 773 {
 774         struct snp_guest_dev *snp_dev = platform_get_drvdata(pdev);
 775
 776         free_shared_pages(snp_dev->certs_data, SEV_FW_BLOB_MAX_SIZE);
 777         free_shared_pages(snp_dev->response, sizeof(struct snp_guest_msg));
 778         free_shared_pages(snp_dev->request, sizeof(struct snp_guest_msg));
 779         deinit_crypto(snp_dev->crypto);
 780         misc_deregister(&snp_dev->misc);
 781
 782         return 0;
 783 }
 784
 785 /*
 786  * This driver is meant to be a common SEV guest interface driver and to
 787  * support any SEV guest API. As such, even though it has been introduced
 788  * with the SEV-SNP support, it is named "sev-guest".
 789  */
 790 static struct platform_driver sev_guest_driver = {
 791         .remove         = __exit_p(sev_guest_remove),
 792         .driver         = {
 793                 .name = "sev-guest",
 794         },
 795 };
 796
 797 module_platform_driver_probe(sev_guest_driver, sev_guest_probe);
 798
 799 MODULE_AUTHOR("Brijesh Singh <brijesh.singh@amd.com>");
 800 MODULE_LICENSE("GPL");
 801 MODULE_VERSION("1.0.0");
 802 MODULE_DESCRIPTION("AMD SEV Guest Driver");