Esempio n. 1
0
def test_power_on_off(nvme0):
    def poweron():
        logging.info("poweron")
        pass
    def poweroff():
        logging.info("poweroff")
        pass
    subsystem = d.Subsystem(nvme0, poweron, poweroff)

    subsystem = d.Subsystem(nvme0)
    subsystem.poweroff()
    subsystem.poweron()
    nvme0.reset()
Esempio n. 2
0
def test_quarch_dirty_power_cycle_single(nvme0, poweron=None, poweroff=None):
    region_end = 256*1000*1000  # 1GB
    qdepth = min(1024, 1+(nvme0.cap&0xffff))
    
    # get the unsafe shutdown count
    def power_cycle_count():
        buf = d.Buffer(4096)
        nvme0.getlogpage(2, buf, 512).waitdone()
        return buf.data(115, 112)
    
    # run the test one by one
    subsystem = d.Subsystem(nvme0, poweron, poweroff)
    nvme0n1 = d.Namespace(nvme0, 1, region_end)
    assert True == nvme0n1.verify_enable(True)
    orig_unsafe_count = power_cycle_count()
    logging.info("power cycle count: %d" % orig_unsafe_count)

    # 128K random write
    cmdlog_list = [None]*1000
    with nvme0n1.ioworker(io_size=256,
                          lba_random=True,
                          read_percentage=0,
                          region_end=256*1000*1000,
                          time=30,
                          qdepth=qdepth, 
                          output_cmdlog_list=cmdlog_list):
        # sudden power loss before the ioworker end
        time.sleep(10)
        subsystem.poweroff()

    # power on and reset controller
    time.sleep(5)
    subsystem.poweron()
    nvme0.reset()

    # verify data in cmdlog_list
    logging.info(cmdlog_list[-10:])
    read_buf = d.Buffer(256*512)
    qpair = d.Qpair(nvme0, 10)
    for cmd in cmdlog_list:
        slba = cmd[0]
        nlba = cmd[1]
        op = cmd[2]
        if nlba and op==1:
            def read_cb(cdw0, status1):
                nonlocal slba
                if status1>>1:
                    logging.info("slba 0x%x, status 0x%x" % (slba, status1>>1))
            #logging.info("verify slba 0x%x, nlba %d" % (slba, nlba))
            nvme0n1.read(qpair, read_buf, slba, nlba, cb=read_cb).waitdone()
            # re-write to clear CRC mismatch
            nvme0n1.write(qpair, read_buf, slba, nlba, cb=read_cb).waitdone()
    qpair.delete()
    nvme0n1.close()

    # verify unsafe shutdown count
    unsafe_count = power_cycle_count()
    logging.info("power cycle count: %d" % unsafe_count)
    assert unsafe_count == orig_unsafe_count+1
Esempio n. 3
0
def test_reset_time(pcie):
    def nvme_init(nvme0):
        logging.info("user defined nvme init")

        nvme0[0x14] = 0
        while not (nvme0[0x1c] & 0x1) == 0:
            pass
        logging.info(time.time())

        # 3. set admin queue registers
        nvme0.init_adminq()
        logging.info(time.time())

        # 5. enable cc.en
        nvme0[0x14] = 0x00460001

        # 6. wait csts.rdy to 1
        while not (nvme0[0x1c] & 0x1) == 1:
            pass
        logging.info(time.time())

        # 7. identify controller
        nvme0.identify(d.Buffer(4096)).waitdone()
        logging.info(time.time())

        nvme0.setfeatures(0x7, cdw11=0x00ff00ff).waitdone()
        nvme0.init_queues(nvme0.getfeatures(0x7).waitdone())

    logging.info("1: nvme init")
    logging.info(time.time())
    nvme0 = d.Controller(pcie, nvme_init_func=nvme_init)
    subsystem = d.Subsystem(nvme0)

    qpair = d.Qpair(nvme0, 10)
    qpair2 = d.Qpair(nvme0, 10)
    qpair3 = d.Qpair(nvme0, 10)
    qpair.delete()
    qpair2.delete()
    qpair3.delete()

    logging.info("2: nvme reset")
    logging.info(time.time())
    nvme0.reset()

    logging.info("3: power cycle")
    subsystem.poweroff()
    logging.info(time.time())
    subsystem.poweron()
    nvme0.reset()
Esempio n. 4
0
def subsystem(nvme0):
    ret = d.Subsystem(nvme0)
    yield ret
    del ret
Esempio n. 5
0
def test_reset_within_ioworker(nvme0, repeat):
    region_end = 256 * 1000 * 1000  # 1GB
    qdepth = min(1024, 1 + (nvme0.cap & 0xffff))

    # get the unsafe shutdown count
    def power_cycle_count():
        buf = d.Buffer(4096)
        nvme0.getlogpage(2, buf, 512).waitdone()
        return buf.data(115, 112)

    # run the test one by one
    subsystem = d.Subsystem(nvme0)
    nvme0n1 = d.Namespace(nvme0, 1, region_end)
    orig_unsafe_count = power_cycle_count()
    logging.info("power cycle count: %d" % orig_unsafe_count)

    # 128K random write
    cmdlog_list = [None] * 1000
    with nvme0n1.ioworker(io_size=256,
                          lba_random=True,
                          read_percentage=30,
                          region_end=region_end,
                          time=10,
                          qdepth=qdepth,
                          output_cmdlog_list=cmdlog_list):
        # sudden power loss before the ioworker end
        time.sleep(5)
        nvme0.reset()

    # verify data in cmdlog_list
    time.sleep(5)
    assert True == nvme0n1.verify_enable(True)
    logging.info(cmdlog_list[-10:])
    read_buf = d.Buffer(256 * 512)
    qpair = d.Qpair(nvme0, 10)
    for cmd in cmdlog_list:
        slba = cmd[0]
        nlba = cmd[1]
        op = cmd[2]
        if nlba:

            def read_cb(cdw0, status1):
                nonlocal _slba
                if status1 >> 1:
                    logging.info("slba %d, 0x%x, _slba 0x%x, status 0x%x" % \
                                 (slba, slba, _slba, status1>>1))

            logging.debug("verify slba %d, nlba %d" % (slba, nlba))
            _nlba = nlba // 16
            for i in range(16):
                _slba = slba + i * _nlba
                nvme0n1.read(qpair, read_buf, _slba, _nlba,
                             cb=read_cb).waitdone()

            # re-write to clear CRC mismatch
            nvme0n1.write(qpair, read_buf, slba, nlba, cb=read_cb).waitdone()
    qpair.delete()
    nvme0n1.close()

    # verify unsafe shutdown count
    unsafe_count = power_cycle_count()
    logging.info("power cycle count: %d" % unsafe_count)
    assert unsafe_count == orig_unsafe_count