#!/usr/bin/python

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

#

""" discovery.py - target discovery checkpoint.  Attempts to find all target

devices on the given system.  The Data Object Cache is populated with the

information.

"""

import copy

import optparse

import os

import platform

import re

import sys

import tempfile

import solaris_install.target.vdevs as vdevs

from bootmgmt.pysol import getmntany, mnttab_open, mnttab_close

from solaris_install import CalledProcessError, Popen, run

from solaris_install.data_object.data_dict import DataObjectDict

from solaris_install.engine import InstallEngine

from solaris_install.engine.checkpoint import AbstractCheckpoint as Checkpoint

from solaris_install.target import CRO_LABEL, Target

from solaris_install.target.libbe import be

from solaris_install.target.libdevinfo import devinfo

from solaris_install.target.libdiskmgt import const, diskmgt

from solaris_install.target.libefi.efi import efi_free, efi_read

from solaris_install.target.logical import BE, Filesystem, Logical, Zpool, Zvol

from solaris_install.target.physical import Disk, DiskProp, DiskGeometry, \

    DiskKeyword, Iscsi, GPTPartition, Partition, Slice

from solaris_install.target.size import Size

CROINFO = "/usr/sbin/croinfo"

DEVFSADM = "/usr/sbin/devfsadm"

DHCPINFO = "/sbin/dhcpinfo"

DLADM = "/usr/sbin/dladm"

EEPROM = "/usr/sbin/eeprom"

FSTYP = "/usr/sbin/fstyp"

ISCSIADM = "/usr/sbin/iscsiadm"

PCFSMOUNT = "/usr/lib/fs/pcfs/mount"

PRTVTOC = "/usr/sbin/prtvtoc"

SVCS = "/usr/bin/svcs"

SVCADM = "/usr/sbin/svcadm"

UMOUNT = "/usr/sbin/umount"

ZFS = "/usr/sbin/zfs"

ZPOOL = "/usr/sbin/zpool"

ZVOL_PATH = "/dev/zvol/dsk"

ZVOL_RPATH = "/dev/zvol/rdsk"

DISK_SEARCH_NAME = "disk"

ZPOOL_SEARCH_NAME = "zpool"

# regex for matching c#t#d# OR c#d# strings.  Use \w rather than \d for the

# "t" to allow matching of WWNs

DISK_RE = "c\d+(?:t\w+)?d\d+"

def retrieve_drive(name):

    """ function to return a drive object based on a specific name

    """

    try:

        # check to see if the search name is either c#t#d# or c#d#

        if re.match(DISK_RE, name, re.I):

            dmd = diskmgt.descriptor_from_key(const.ALIAS, name)

            alias = diskmgt.DMAlias(dmd.value)

            drive = alias.drive

        else:

            dmd = diskmgt.descriptor_from_key(const.DRIVE, name)

            drive = diskmgt.DMDrive(dmd.value)

    except (KeyError, OSError) as err:

        raise RuntimeError("Unable to look up %s - %s" % (name, err))

    return drive

class TargetDiscovery(Checkpoint):

    """ Discover all logical and physical devices on the system.

    """

    def __init__(self, name, search_name=None, search_type=None):

        super(TargetDiscovery, self).__init__(name)

        self.dry_run = False

        self.eng = InstallEngine.get_instance()

        self.doc = self.eng.data_object_cache

        # create a root node to insert all discovered objects into

        self.root = Target(Target.DISCOVERED)

        # user specified search criteria

        self.search_name = search_name

        self.search_type = search_type

        # list of discovered swap and dump zvols

        self.swap_list = list()

        self.dump_list = list()

        # eeprom diag mode and bootdisk value

        self.sparc_diag_mode = False

        self.bootdisk = None

        # kernel architecture

        self.arch = platform.processor()

        # croinfo dictionary

        self.cro_dict = dict()

    def is_bootdisk(self, name):

        """ is_bootdisk() -- simple method to compare the name of the disk in

        question with what libdevinfo reports as the bootdisk

        name - ctd name of the disk to check

        """

        # cache the answer so we don't do multiple lookups to libdevinfo

        if self.bootdisk is None:

            self.bootdisk = devinfo.get_curr_bootdisk()

        return self.bootdisk == name

    def get_progress_estimate(self):

        # XXX

        return 1

    def discover_disk(self, drive):

        """ discover_disk - method to discover a physical disk's attributes,

        partitions and slices

        drive - which physical drive to parse

        """

        # create a DOC object for this drive.  Set validate_children to False

        # so the shadow code doesn't adjust the start sector or size for any

        # children discovered

        new_disk = Disk("disk", validate_children=False)

        # extract drive attributes and media information

        drive_attributes = drive.attributes

        drive_media = drive.media

        # if a drive is offline or down return None

        if drive_attributes.status == "DOWN":

            self.logger.debug("disk '%s' is offline" % new_disk.name)

            return None

        for alias in drive.aliases:

            if drive_media is not None:

                if self.verify_disk_read(alias.name,

                                         drive_media.attributes.blocksize):

                    new_disk.active_ctds.append(alias.name)

                else:

                    new_disk.passive_ctds.append(alias.name)

        # set the new_disk ctd string

        if new_disk.wwn is None:

            # use the only alias name

            new_disk.ctd = drive.aliases[0].name

        else:

            # use the first active ctd

            new_disk.ctd = new_disk.active_ctds[0]

        new_disk.devid = drive.name

        new_disk.iscdrom = drive.cdrom

        new_disk.opath = drive_attributes.opath

        # set the devpath

        if os.path.islink(drive_attributes.opath):

            link = os.readlink(drive_attributes.opath)

            # clean up the link to get rid of the leading '../../devices/' and

            # trailing minor name

            if link.startswith("../../devices") and ":" in link:

                link = link.partition("../../devices")[2].rpartition(":")[0]

                new_disk.devpath = link

        # check for SPARC eeprom settings which would interfere with finding

        # the boot disk

        if self.arch == "sparc":

            if not self.sparc_diag_mode:

                # check eeprom settings

                cmd = [EEPROM, "diag-switch?"]

                p = run(cmd)

                diag_switch_value = p.stdout.partition("=")[2]

                if diag_switch_value.strip().lower() == "true":

                    # set a variable so we don't check every single disk and

                    # log a message

                    self.sparc_diag_mode = True

                    self.logger.info("Unable to determine bootdisk with " + \

                                     "diag-switch? eeprom setting set to " + \

                                     "'true'.  Please set diag-switch? " + \

                                     "to false and reboot the system")

        # check for the bootdisk

        if not self.sparc_diag_mode:

            if self.is_bootdisk(new_disk.ctd):

                new_disk.disk_keyword = DiskKeyword()

        # set vendor information for the drive

        new_disk.disk_prop = DiskProp()

        if drive.controllers:

            new_disk.disk_prop.dev_type = drive.controllers[0].attributes.type

            # check for any Iscsi object in the DOC.  If found, change the

            # dev_type from 'scsi' to 'iSCSI' to allow the installers finer

            # granularity when choosing these types of LUNs

            iscsi_check = self.doc.get_descendants(class_type=Iscsi)

            if iscsi_check:

                cmd = [ISCSIADM, "list", "target", "-S"]

                p = run(cmd)

                if new_disk.ctd in p.stdout:

                    new_disk.disk_prop.dev_type = "iSCSI"

        new_disk.disk_prop.dev_vendor = drive_attributes.vendor_id

        # set the alias and receptacle for disks, if possible

        if not new_disk.iscdrom and new_disk.ctd in self.cro_dict:

            new_disk.disk_prop.dev_chassis = self.cro_dict[new_disk.ctd][1]

            new_disk.receptacle = self.cro_dict[new_disk.ctd][2]

        # walk the media node to extract partitions and slices

        if drive_media is None:

            # since the drive has no media, we can't determine any attributes

            # about it (geometry, slices, partitions, etc.) so simply return

            # None

            return None

        else:

            # store the attributes locally so libdiskmgt doesn't have to keep

            # looking them up

            drive_media_attributes = drive_media.attributes

            # retrieve the drive's geometry

            new_disk = self.set_geometry(drive_media_attributes, new_disk)

            # keep a list of slices already visited so they're not discovered

            # again later

            visited_slices = []

            # if this system is x86 and the drive reports *VTOC* slices but no

            # fdisk partitions, don't report any of the slices. This probably

            # means there is no label at all on the disk:

            # On x86 libdiskmgmt will report slices, but no partitions

            # when the disk has no partition table/label at all.

            if self.arch == "i386" \

                and drive_media.slices \

                and not drive_media.partitions \

                and new_disk.label != "GPT":

                # Unset the erroneous disk label

                new_disk._label = None

                return new_disk

            if new_disk.label == "VTOC":

                for partition in drive_media.partitions:

                    new_partition = self.discover_partition(partition,

                        drive_media_attributes.blocksize)

                    # add the partition to the disk object

                    new_disk.insert_children(new_partition)

                    # check for slices associated with this partition

                    # if found, add them as children

                    for slc in partition.media.slices:

                        # discover the slice

                        new_slice = self.discover_slice(slc,

                            drive_media_attributes.blocksize)

                        # constrain when a slice is added to the DOC.

                        # We only want to add a slice when the partition id

                        # is a Solaris partition (non EFI)

                        if new_partition.is_solaris:

                            new_partition.insert_children(new_slice)

                        # keep a record this slice so it's not discovered again

                        visited_slices.append(slc.name)

                for slc in drive_media.slices:

                    # discover the slice if it's not already been found

                    if slc.name not in visited_slices:

                        new_slice = self.discover_slice(slc,

                            drive_media_attributes.blocksize)

                        new_disk.insert_children(new_slice)

            # If the disk has a GPT label then the protective MBR

            # reported by libdiskmgt should be ignored. The GPT partitions

            # are reported by libdiskmgt as "slices", similar to VTOC slices

            elif new_disk.label == "GPT":

                # EFI/GPT label on disc. Discover GPT partitions.

                # libdiskmgt's information about GPT partitions is incomplete

                # so use libefi to fill in what is missing.

                fh = os.open(new_disk.opath, os.O_RDONLY | os.O_NDELAY)

                try:

                    gptp = efi_read(fh)

                    try:

                        for slc in drive_media.slices:

                            efi_part = gptp.contents.efi_parts[

                                slc.attributes.index]

                            new_gpart = self.discover_gptpartition(slc,

                                drive_media_attributes.blocksize,

                                efi_part)

                            new_disk.insert_children(new_gpart)

                    finally:

                        efi_free(gptp)

                finally:

                    os.close(fh)

            return new_disk

    def verify_disk_read(self, ctd, blocksize):

        """

        verify_disk_read() - method to verify a low-level read from the raw ctd

        path.

        """

        raw = "/dev/rdsk/%s" % ctd

        raw2 = raw + "s2"

        # Depending on the label used, we need to check both the raw device and

        # slice 2 to see if the disk can be read.

        for raw_disk in [raw, raw2]:

            fd = None

            try:

                try:

                    fd = os.open(raw_disk, os.O_RDONLY | os.O_NDELAY)

                    try:

                        _none = os.read(fd, blocksize)

                    except OSError:

                        # the read() call failed

                        continue

                    else:

                        return True

                except OSError:

                    # the open() call failed

                    continue

            finally:

                if fd is not None:

                    os.close(fd)

        return False

    def set_geometry(self, dma, new_disk):

        """ set_geometry() - method to set the geometry of the Disk DOC object

        from the libdiskmgt drive object.

        dma - the drive's media attributes as returned by libdiskmgt

        new_disk - Disk DOC object

        """

        new_geometry = None

        # If the disk has a GPT label (or no label), ncylinders will be

        # None

        if dma.ncylinders is None:

            # XXX - libdiskmgt calculation of DM_NACCESSIBLE for GPT disks

            # is broken, so we use DM_SIZE since we can access all blocks on

            # the disk anyway because we don't need to worry about VTOC

            # imposed cylinder alignment on disk size.

            # Bugster CR: 7099417

            new_disk.disk_prop.dev_size = Size(str(dma.size) +

                                               Size.sector_units,

                                               dma.blocksize)

            # set only the blocksize (not the cylinder size)

            new_geometry = DiskGeometry(dma.blocksize, None)

            # set the label of the disk, if possible

            if dma.efi:

                new_disk.label = "GPT"

                new_geometry.efi = True

        else:

            new_disk.label = "VTOC"

            # set the disk's volid

            new_disk.volid = dma.label

            ncyl = dma.ncylinders

            nhead = dma.nheads

            nsect = dma.nsectors

            new_disk.disk_prop.dev_size = Size(str(dma.naccessible) +

                                               Size.sector_units,

                                               dma.blocksize)

            new_geometry = DiskGeometry(dma.blocksize, nhead * nsect)

            new_geometry.ncyl = ncyl

            new_geometry.nheads = nhead

            new_geometry.nsectors = nsect

        new_disk.geometry = new_geometry

        return new_disk

    def discover_pseudo(self, controller):

        """ discover_psuedo - method to discover pseudo controller information,

        usually zvol swap and dump

        """

        for drive in controller.drives:

            for slc in drive.media.slices:

                stats = slc.use_stats

                if "used_by" in stats:

                    if stats["used_name"][0] == "dump":

                        if slc.name.startswith(ZVOL_PATH):

                            # remove the /dev/zvol/dsk from the path

                            self.dump_list.append(slc.name[14:])

                    if stats["used_name"][0] == "swap":

                        if slc.name.startswith(ZVOL_PATH):

                            # remove the /dev/zvol/dsk from the path

                            self.swap_list.append(slc.name[14:])

    def discover_partition(self, partition, blocksize):

        """ discover_partition - method to discover a physical disk's

        partition layout

        partition - partition object as discovered by ldm

        blocksize - blocksize of the disk

        """

        # store the attributes locally so libdiskmgt doesn't have to keep

        # looking them up

        partition_attributes = partition.attributes

        # partition name is ctdp path.  Split the string on "p"

        root_path, _none, index = partition.name.partition("p")

        # create a DOC object for this partition.  Set validate_children to

        # False so the shadow code doesn't adjust the start sector or size for

        # any children discovered

        new_partition = Partition(index, validate_children=False)

        new_partition.action = "preserve"

        new_partition.part_type = partition_attributes.id

        # check the partition's ID to set the partition type correctly

        if partition_attributes.id == \

            Partition.name_to_num("Solaris/Linux swap"):

            try:

                # try to call prtvtoc on slice 2.  If it succeeds, this is a

                # solaris1 partition.

                slice2 = root_path + "s2"

                cmd = [PRTVTOC, slice2]

                run(cmd, stdout=Popen.DEVNULL)

            except CalledProcessError:

                # the call to prtvtoc failed which means this partition is

                # Linux swap. To be sure, prtvtoc failure might also mean an

                # unlabeled Solaris1 partition but we aren't going to worry

                # about that for now. Displaying an unlabeled (and therefore

                # unused) Solaris1 partition should not have any unforeseen

                # consequences in terms of data loss.

                new_partition.is_linux_swap = True

        new_partition.size = Size(str(partition_attributes.nsectors) + \

                             Size.sector_units, blocksize=blocksize)

        new_partition.start_sector = long(partition_attributes.relsect)

        new_partition.size_in_sectors = partition_attributes.nsectors

        # If the partition is an EFI system partition check to see if it

        # is PCFS formatted. We only do this on EFI system partitions to save

        # time since mounting can be slow.

        if new_partition.is_efi_system:

            ctdp = partition.name.rsplit('/', 1)[-1]

            new_partition._is_pcfs_formatted = self.is_pcfs_formatted(ctdp)

        return new_partition

    def discover_gptpartition(self, partition, blocksize, efipart):

        """ discover_gptpartition - method to discover a physical disk's GPT

        partition layout.

        # Note that libdiskmgmt terminology treats GPT partitions as slices

        # as does the Solaris cXtYdZsN notation

        # We shall refer to them as GPT partitions though, like the rest of

        # the world does.

        partition - object as discovered by ldm

        blocksize - blocksize of the disk

        efipart - DK_PART EFI cstruct

        """

        # store the attributes locally so libdiskmgt doesn't have to keep

        # looking them up

        gpart_attributes = partition.attributes