# Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging, os, re
from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error


class hardware_StorageWearoutDetect(test.test):
    """
    Check wear out status for storage device available in SMART for SSD and
    in ext_csd for eMMC version 5.0 or later. For previous version of eMMC,
    it will be treat as data not available.

    The test will be failed if:
    - At least one SMART variable has value under its threshold
      or
    - Percentage Used reported by SMART for NVMe or SATA is above 90
      or
    - eMMC wear out status variable is in 90-100% band or higher (
      DEVICE_LIFE_TIME_EST_TYP_A). Seeing this consistently means the lab
      device may have to be replaced.
    """

    version = 1
    STORAGE_INFO_PATH = '/var/log/storage_info.txt'
    STORAGE_INFO_COMMON_PATH = '/usr/share/misc/storage-info-common.sh'

    # Example     "SATA Version is: SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)"
    SATA_DETECT = r"SATA Version is:.*"

    # Example     "   Extended CSD rev 1.7 (MMC 5.0)"
    MMC_DETECT = r"\s*Extended CSD rev.*MMC (?P<version>\d+.\d+)"

    # Example     "SMART/Health Information (NVMe Log 0x02, NSID 0xffffffff)"
    NVME_DETECT = r".*NVMe Log .*"

    # Field meaning and example line that have failing attribute
    # ID# ATTRIBUTE_NAME          FLAGS    VALUE WORST THRESH FAIL RAW_VALUE
    # 184 End-to-End_Error        PO--CK   001   001   097    NOW  135
    SSD_FAIL = r"""\s*(?P<param>\S+\s\S+)      # ID and attribute name
                   \s+[P-][O-][S-][R-][C-][K-] # flags
                   (\s+\d{3}){3}               # three 3-digits numbers
                   \s+NOW                      # fail indicator"""

    # We want to detect and fail if we see a non-zero value for either
    # attribute 160 Uncorrectable_Error_Cnt or attribute 187 Reported_Uncorrect
    # ID# ATTRIBUTE_NAME          FLAGS    VALUE WORST THRESH FAIL RAW_VALUE
    # 160 Uncorrectable_Error_Cnt -----    100   100   100     -   10
    SATA_FAIL = r"""\s*(?P<param>(160\s+Uncorrectable_Error_Cnt|
                    187\s+Reported_Uncorrect))
                    \s+[P-][O-][S-][R-][C-][K-]
                    (\s+\d{1,3}){3}
                    \s+(NOW|[-])
                    \s+[1-9][0-9]*"""

    # Ex "Pre EOL information [PRE_EOL_INFO: 0x02]"
    # 0x02 means Warning, consumed 80% of reserved blocks
    # 0x03 means Urgent
    MMC_FAIL = r".*(?P<param>PRE_EOL_INFO]?: 0x0[23])"

    # Ex Available Spare:                    100%
    # We want to fail when the available spare is below the
    # available spare threshold.
    NVME_SPARE = r"Available Spare:\s+(?P<param>\d{1,3})%"

    #Available Spare Threshold:          10%
    NVME_THRESH = r"Available Spare Threshold:\s+(?P<param>\d{1,3})%"

    def run_once(self, use_cached_result=True):
        """
        Run the test

        @param use_cached_result: Use the result that generated when machine
                                  booted or generate new one.
        """

        if not use_cached_result:
            if not os.path.exists(self.STORAGE_INFO_COMMON_PATH):
                msg = str('Test failed with error: %s not exist'
                          % self.STORAGE_INFO_COMMON_PATH)
                raise error.TestFail(msg)
            cmd = ' '.join(['. %s;' % (self.STORAGE_INFO_COMMON_PATH, ),
                            'get_storage_info'])
            utils.run(cmd, stdout_tee=open(self.STORAGE_INFO_PATH, 'w'),
                      stderr_tee=utils.TEE_TO_LOGS)

        # Check that storage_info file exist.
        if not os.path.exists(self.STORAGE_INFO_PATH):
            msg = str('Test failed with error: %s not exist'
                      % self.STORAGE_INFO_PATH)
            raise error.TestFail(msg)

        mmc_detect = False
        sata_detect = False
        legacy_mmc = False
        nvme_detect = False
        fail_msg = ''

        with open(self.STORAGE_INFO_PATH) as f:
            for line in f:
                m = re.match(self.SATA_DETECT, line)
                if m:
                    sata_detect = True
                    logging.info('Found SATA device')

                m = re.match(self.MMC_DETECT, line)
                if m:
                    version = m.group('version')
                    if float(version) < 5.0:
                        legacy_mmc = True
                    mmc_detect = True
                    logging.info('Found eMMC version %s', version)

                m = re.match(self.NVME_DETECT, line)
                if m:
                    nvme_detect = True
                    logging.info('Found NVMe device')

                m = re.match(self.SSD_FAIL, line, re.X)
                if m:
                    param = m.group('param')
                    fail_msg += 'SSD failure ' + param

                m = re.match(self.MMC_FAIL, line)
                if m:
                    param = m.group('param')
                    fail_msg += 'MMC failure ' + param

                m = re.match(self.SATA_FAIL, line, re.X)
                if m:
                    param = m.group('param')
                    fail_msg += 'SATA failure, attribute ' + param

                m = re.match(self.NVME_SPARE, line)
                if m:
                    # Check the next line for the available spare threshold.
                    # Fail if available spare is below the threshold.
                    spare = m.group('param')
                    nextLine = next(f)
                    nm = re.match(self.NVME_THRESH, nextLine)
                    if nm:
                        thresh = nm.group('param')
                        if int(spare) < int(thresh):
                            fail_msg += 'NVMe failure, Available Spare ' + \
                                        spare + '% below threshold ' + \
                                        thresh + '%'

        if not sata_detect and not mmc_detect and not nvme_detect:
            raise error.TestFail('Can not detect storage device.')

        if fail_msg:
            msg = 'Detected wearout parameter:%s' % fail_msg
            raise error.TestFail(msg)

        if legacy_mmc:
            msg = 'eMMC version %s detected. ' % version
            msg += 'Wearout attributes are supported in eMMC 5.0 and later.'
            logging.info(msg)