LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/nvme/nvme_opal.c - nvme_opal_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 80 83 96.4 %
Date: 2024-07-16 01:00:24 Functions: 7 14 50.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 2 10 20.0 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2021 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : #include "spdk_internal/cunit.h"
       8                 :            : #include "nvme/nvme_opal.c"
       9                 :            : #include "common/lib/test_env.c"
      10                 :            : 
      11                 :          3 : SPDK_LOG_REGISTER_COMPONENT(nvme)
      12                 :            : 
      13         [ -  + ]:          6 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_security_receive, int,
      14                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint8_t secp, uint16_t spsp,
      15                 :            :              uint8_t nssf, void *payload, uint32_t payload_size,
      16                 :            :              spdk_nvme_cmd_cb cb_fn, void *cb_arg), 1);
      17                 :            : 
      18         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_security_receive, int,
      19                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
      20                 :            :              uint16_t spsp, uint8_t nssf, void *payload, size_t size), 0);
      21                 :            : 
      22         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_process_admin_completions, int,
      23                 :            :             (struct spdk_nvme_ctrlr *ctrlr), 0);
      24                 :            : 
      25         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_security_send, int,
      26                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
      27                 :            :              uint16_t spsp, uint8_t nssf, void *payload,
      28                 :            :              uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
      29                 :            : 
      30                 :            : static int g_ut_recv_status = 0;
      31                 :            : static void *g_ut_sess_ctx;
      32                 :            : 
      33                 :            : static void
      34                 :         15 : ut_opal_sess_cb(struct opal_session *sess, int status, void *ctx)
      35                 :            : {
      36                 :         15 :         g_ut_recv_status = status;
      37                 :         15 :         g_ut_sess_ctx = ctx;
      38                 :         15 : }
      39                 :            : 
      40                 :            : static void
      41                 :         15 : reset_ut_global_variables(void)
      42                 :            : {
      43                 :         15 :         g_ut_recv_status = 0;
      44                 :         15 :         g_ut_sess_ctx = NULL;
      45                 :         15 : }
      46                 :            : 
      47                 :            : static void
      48                 :          3 : test_opal_nvme_security_recv_send_done(void)
      49                 :            : {
      50                 :          3 :         struct spdk_nvme_cpl cpl = {};
      51                 :          3 :         struct spdk_opal_compacket header = {};
      52                 :          3 :         struct spdk_opal_dev dev = {};
      53                 :          3 :         struct opal_session sess = {};
      54                 :            : 
      55                 :          3 :         sess.sess_cb = ut_opal_sess_cb;
      56                 :          3 :         sess.cb_arg = (void *)0xDEADBEEF;
      57                 :          3 :         sess.dev = &dev;
      58                 :          3 :         memcpy(sess.resp, &header, sizeof(header));
      59                 :            : 
      60                 :            :         /* Case 1: receive/send IO error */
      61                 :          3 :         reset_ut_global_variables();
      62                 :          3 :         cpl.status.sct = SPDK_NVME_SCT_MEDIA_ERROR;
      63                 :            : 
      64                 :          3 :         opal_nvme_security_recv_done(&sess, &cpl);
      65                 :          3 :         CU_ASSERT(g_ut_recv_status == -EIO);
      66                 :          3 :         CU_ASSERT(g_ut_sess_ctx == (void *)0xDEADBEEF);
      67                 :            : 
      68                 :          3 :         reset_ut_global_variables();
      69                 :          3 :         opal_nvme_security_send_done(&sess, &cpl);
      70                 :          3 :         CU_ASSERT(g_ut_recv_status == -EIO);
      71                 :          3 :         CU_ASSERT(g_ut_sess_ctx == (void *)0xDEADBEEF);
      72                 :            : 
      73                 :            :         /* Case 2: receive with opal header no outstanding data */
      74                 :          3 :         reset_ut_global_variables();
      75         [ -  + ]:          3 :         memset(&header, 0, sizeof(header));
      76                 :          3 :         cpl.status.sct = SPDK_NVME_SCT_GENERIC;
      77                 :            : 
      78                 :          3 :         opal_nvme_security_recv_done(&sess, &cpl);
      79                 :          3 :         CU_ASSERT(g_ut_recv_status == 0);
      80                 :          3 :         CU_ASSERT(g_ut_sess_ctx == (void *)0xDEADBEEF);
      81                 :            : 
      82                 :            :         /* Case 3: receive with opal header outstanding data and send done success */
      83                 :          3 :         reset_ut_global_variables();
      84                 :          3 :         header.outstanding_data = 0xff;
      85                 :          3 :         memcpy(sess.resp, &header, sizeof(header));
      86                 :          3 :         cpl.status.sct = SPDK_NVME_SCT_GENERIC;
      87                 :            : 
      88                 :          3 :         opal_nvme_security_recv_done(&sess, &cpl);
      89                 :          3 :         CU_ASSERT(g_ut_recv_status == 1);
      90                 :          3 :         CU_ASSERT(g_ut_sess_ctx == (void *)0xDEADBEEF);
      91                 :            : 
      92                 :          3 :         reset_ut_global_variables();
      93                 :          3 :         opal_nvme_security_send_done(&sess, &cpl);
      94                 :          3 :         CU_ASSERT(g_ut_recv_status == 1);
      95                 :          3 :         CU_ASSERT(g_ut_sess_ctx == (void *)0xDEADBEEF);
      96                 :          3 : }
      97                 :            : 
      98                 :            : static void
      99                 :          3 : test_opal_add_short_atom_header(void)
     100                 :            : {
     101                 :          3 :         struct opal_session sess = {};
     102                 :          3 :         int err = 0;
     103                 :            : 
     104                 :            :         /* short atom header */
     105                 :          3 :         memset(&sess, 0, sizeof(sess));
     106                 :          3 :         sess.cmd_pos = 0;
     107                 :            : 
     108                 :          3 :         opal_add_token_bytestring(&err, &sess, spdk_opal_uid[UID_SMUID],
     109                 :            :                                   OPAL_UID_LENGTH);
     110                 :          3 :         CU_ASSERT(sess.cmd[0] & SPDK_SHORT_ATOM_ID);
     111                 :          3 :         CU_ASSERT(sess.cmd[0] & SPDK_SHORT_ATOM_BYTESTRING_FLAG);
     112                 :          3 :         CU_ASSERT((sess.cmd[0] & SPDK_SHORT_ATOM_SIGN_FLAG) == 0);
     113                 :          3 :         CU_ASSERT(sess.cmd_pos == OPAL_UID_LENGTH +  1);
     114                 :          3 :         CU_ASSERT(!memcmp(&sess.cmd[1], spdk_opal_uid, OPAL_UID_LENGTH + 1));
     115                 :            : 
     116                 :            :         /* medium atom header */
     117                 :          3 :         memset(&sess, 0, sizeof(sess));
     118                 :          3 :         sess.cmd_pos = 0;
     119                 :            : 
     120                 :          3 :         opal_add_token_bytestring(&err, &sess, spdk_opal_uid[UID_SMUID],
     121                 :            :                                   0x10);
     122                 :          3 :         CU_ASSERT(sess.cmd[0] & SPDK_SHORT_ATOM_ID);
     123                 :          3 :         CU_ASSERT(sess.cmd[0] & SPDK_MEDIUM_ATOM_BYTESTRING_FLAG);
     124                 :          3 :         CU_ASSERT((sess.cmd[0] & SPDK_MEDIUM_ATOM_SIGN_FLAG) == 0);
     125                 :          3 :         CU_ASSERT(sess.cmd_pos == 0x12);
     126                 :          3 :         CU_ASSERT(!memcmp(&sess.cmd[2], spdk_opal_uid, 0x10));
     127                 :            : 
     128                 :            :         /* Invalid length */
     129                 :          3 :         memset(&sess, 0, sizeof(sess));
     130                 :          3 :         err = 0;
     131                 :            : 
     132                 :          3 :         opal_add_token_bytestring(&err, &sess, spdk_opal_uid[UID_SMUID],
     133                 :            :                                   0x1000);
     134                 :          3 :         CU_ASSERT(err == -ERANGE);
     135                 :          3 :         CU_ASSERT(sess.cmd_pos == 0);
     136                 :          3 : }
     137                 :            : 
     138                 :            : int
     139                 :          3 : main(int argc, char **argv)
     140                 :            : {
     141                 :          3 :         CU_pSuite       suite = NULL;
     142                 :            :         unsigned int    num_failures;
     143                 :            : 
     144                 :          3 :         CU_initialize_registry();
     145                 :            : 
     146                 :          3 :         suite = CU_add_suite("nvme_opal", NULL, NULL);
     147                 :          3 :         CU_ADD_TEST(suite, test_opal_nvme_security_recv_send_done);
     148                 :          3 :         CU_ADD_TEST(suite, test_opal_add_short_atom_header);
     149                 :            : 
     150                 :          3 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     151                 :          3 :         CU_cleanup_registry();
     152                 :          3 :         return num_failures;
     153                 :            : }

Generated by: LCOV version 1.14