diff --git a/contrib/devstack/lib/manila b/contrib/devstack/lib/manila
index 0b50ace3c4..ac154cf89c 100644
--- a/contrib/devstack/lib/manila
+++ b/contrib/devstack/lib/manila
@@ -142,6 +142,7 @@ function configure_default_backends {
         iniset $MANILA_CONF $group_name service_image_name $MANILA_SERVICE_IMAGE_NAME
         iniset $MANILA_CONF $group_name service_instance_user $MANILA_SERVICE_INSTANCE_USER
         iniset $MANILA_CONF $group_name service_instance_password $MANILA_SERVICE_INSTANCE_PASSWORD
+        iniset $MANILA_CONF $group_name driver_handles_share_servers True
     done
 }
 
diff --git a/manila/common/constants.py b/manila/common/constants.py
index b3ed617ecd..0b67610881 100644
--- a/manila/common/constants.py
+++ b/manila/common/constants.py
@@ -51,11 +51,3 @@ PING_PORTS = (
 
 SERVICE_INSTANCE_SECGROUP_DATA = (
     CIFS_PORTS + NFS_PORTS + SSH_PORTS + PING_PORTS)
-
-SINGLE_SVM_MODE = 'single_svm'
-MULTI_SVM_MODE = 'multi_svm'
-
-VALID_SHARE_DRIVER_MODES = (
-    SINGLE_SVM_MODE,
-    MULTI_SVM_MODE,
-)
diff --git a/manila/share/driver.py b/manila/share/driver.py
index 627cb6a7fa..61eeaa1eaf 100644
--- a/manila/share/driver.py
+++ b/manila/share/driver.py
@@ -1,4 +1,5 @@
 # Copyright 2012 NetApp
+# Copyright 2015 Mirantis inc.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -20,9 +21,7 @@ Drivers for shares.
 import time
 
 from oslo.config import cfg
-import six
 
-from manila.common import constants
 from manila import exception
 from manila.i18n import _LE
 from manila import network
@@ -53,13 +52,15 @@ share_opts = [
              "If not set, the share backend's config group will be used."
              "If an option is not found within provided group, then"
              "'DEFAULT' group will be used for search of option."),
-    cfg.StrOpt(
-        'share_driver_mode',
-        default=None,
-        help="One specific mode for driver to use. Available values: "
-             "%s. What modes are supported and can be used is "
-             "up to driver. If set None then default will be used." %
-             six.text_type(constants.VALID_SHARE_DRIVER_MODES)),
+    cfg.BoolOpt(
+        'driver_handles_share_servers',
+        help="There are two possible approaches for share drivers in Manila. "
+             "First is when share driver is able to handle share-servers and "
+             "second when not. Drivers can support either both or only one "
+             "of these approaches. So, set this opt to True if share driver "
+             "is able to handle share servers and it is desired mode else set "
+             "False. It is set to None by default to make this choice "
+             "intentional."),
 ]
 
 ssh_opts = [
@@ -153,17 +154,32 @@ class GaneshaMixin(object):
 class ShareDriver(object):
     """Class defines interface of NAS driver."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, driver_handles_share_servers, *args, **kwargs):
+        """Implements base functionality for share drivers.
+
+        :param driver_handles_share_servers: expected boolean value or
+            tuple/list/set of boolean values.
+            There are two possible approaches for share drivers in Manila.
+            First is when share driver is able to handle share-servers and
+            second when not.
+            Drivers can support either both or only one of these approaches.
+            So, it is allowed to be 'True' when share driver does support
+            handling of share servers and allowed to be 'False' when does
+            support usage of unhandled share-servers that are not tracked by
+            Manila.
+            Share drivers are allowed to work only in one of two possible
+            driver modes, that is why only one should be chosen.
+        """
         super(ShareDriver, self).__init__()
         self.configuration = kwargs.get('configuration', None)
         if self.configuration:
             self.configuration.append_config_values(share_opts)
             network_config_group = (self.configuration.network_config_group or
                                     self.configuration.config_group)
-            self.mode = self.configuration.safe_get('share_driver_mode')
         else:
             network_config_group = None
-            self.mode = CONF.share_driver_mode
+
+        self._verify_share_server_handling(driver_handles_share_servers)
 
         if hasattr(self, 'init_execute_mixin'):
             # Instance with 'ExecuteMixin'
@@ -173,55 +189,36 @@ class ShareDriver(object):
             self.init_execute_mixin(*args, **kwargs)  # pylint: disable=E1101
         self.network_api = network.API(config_group_name=network_config_group)
 
-    def _validate_driver_mode(self, mode):
-        valid = constants.VALID_SHARE_DRIVER_MODES
-        if mode not in valid:
-            data = {'mode': mode, 'valid': valid}
-            msg = ("Provided unsupported driver mode '%(mode)s'. List of "
-                   "valid driver modes is %(valid)s." % data)
-            LOG.error(msg)
-            raise exception.InvalidParameterValue(msg)
-        return mode
+    @property
+    def driver_handles_share_servers(self):
+        if self.configuration:
+            return self.configuration.safe_get('driver_handles_share_servers')
+        return CONF.driver_handles_share_servers
 
-    def get_driver_mode(self, supported_driver_modes):
-        """Verify and return driver mode.
+    def _verify_share_server_handling(self, driver_handles_share_servers):
+        if not isinstance(self.driver_handles_share_servers, bool):
+            raise exception.ManilaException(
+                "Config opt 'driver_handles_share_servers' has improper "
+                "value - '%s'. Please define it as boolean." %
+                self.driver_handles_share_servers)
+        elif isinstance(driver_handles_share_servers, bool):
+            driver_handles_share_servers = [driver_handles_share_servers]
+        elif not isinstance(driver_handles_share_servers, (tuple, list, set)):
+            raise exception.ManilaException(
+                "Improper data provided for 'driver_handles_share_servers' - "
+                "%s" % driver_handles_share_servers)
 
-        Call this method within share driver to get value for 'mode' attr,
+        if any(not isinstance(v, bool) for v in driver_handles_share_servers):
+            raise exception.ManilaException(
+                "Provided wrong data: %s" % driver_handles_share_servers)
 
-        :param supported_driver_modes: text value or list/tuple of text values
-            with supported modes by share driver, see list of available values
-            in manila.common.constants.VALID_SHARE_DRIVER_MODES
-        :returns: text_type -- name of enabled driver mode.
-        :raises: exception.InvalidParameterValue
-        """
-        msg = None
-
-        if isinstance(supported_driver_modes, six.string_types):
-            supported_driver_modes = [supported_driver_modes, ]
-
-        if not isinstance(supported_driver_modes, (tuple, list)):
-            msg = ("Provided param 'supported_driver_modes' has unexpected "
-                   "type - '%s'." % type(supported_driver_modes))
-        elif not len(supported_driver_modes):
-            msg = "At least one mode should be supported by share driver."
-        elif self.mode:
-            if self.mode not in supported_driver_modes:
-                data = {'mode': self.mode, 'supported': supported_driver_modes}
-                msg = ("Unsupported driver mode '%(mode)s' is provided. "
-                       "List of supported is %(supported)s." % data)
-            else:
-                return self._validate_driver_mode(self.mode)
-        elif len(supported_driver_modes) > 1:
-            msg = ("Driver mode was not specified explicitly and amount of "
-                   "supported driver modes %s is bigger than one, please "
-                   "specify it using config option 'share_driver_mode'." %
-                   six.text_type(supported_driver_modes))
-
-        if msg:
-            LOG.error(msg)
-            raise exception.InvalidParameterValue(msg)
-
-        return self._validate_driver_mode(supported_driver_modes[0])
+        if (self.driver_handles_share_servers not in
+                driver_handles_share_servers):
+            raise exception.ManilaException(
+                "Driver does not support mode 'driver_handles_share_servers="
+                "%(actual)s'. It can be used only with value '%(allowed)s'." %
+                {'actual': self.driver_handles_share_servers,
+                 'allowed': driver_handles_share_servers})
 
     def create_share(self, context, share, share_server=None):
         """Is called to create share."""
@@ -258,11 +255,9 @@ class ShareDriver(object):
 
     def check_for_setup_error(self):
         """Check for setup error."""
-        pass
 
     def do_setup(self, context):
         """Any initialization the share driver does while starting."""
-        pass
 
     def get_share_stats(self, refresh=False):
         """Get share status.
@@ -300,31 +295,61 @@ class ShareDriver(object):
         if self.get_network_allocations_number():
             self.network_api.deallocate_network(context, share_server_id)
 
-    def setup_server(self, network_info, metadata=None):
-        """Set up and configures share server with given network parameters."""
-        pass
+    def setup_server(self, *args, **kwargs):
+        if self.driver_handles_share_servers:
+            return self._setup_server(*args, **kwargs)
+        else:
+            LOG.debug(
+                "Skipping step 'setup share server', because driver is "
+                "enabled with mode when Manila does not handle share servers.")
 
-    def teardown_server(self, server_details, security_services=None):
-        """Teardown share server."""
-        pass
+    def _setup_server(self, network_info, metadata=None):
+        """Sets up and configures share server with given network parameters.
 
-    def _update_share_stats(self):
-        """Retrieve stats info from share group."""
+        Redefine it within share driver when it is going to handle share
+        servers.
+        """
+        raise NotImplementedError()
+
+    def teardown_server(self, *args, **kwargs):
+        if self.driver_handles_share_servers:
+            return self._teardown_server(*args, **kwargs)
+        else:
+            LOG.debug(
+                "Skipping step 'teardown share server', because driver is "
+                "enabled with mode when Manila does not handle share servers.")
+
+    def _teardown_server(self, server_details, security_services=None):
+        """Tears down share server.
+
+        Redefine it within share driver when it is going to handle share
+        servers.
+        """
+        raise NotImplementedError()
+
+    def _update_share_stats(self, data=None):
+        """Retrieve stats info from share group.
+
+        :param data: dict -- dict with key-value pairs to redefine common ones.
+        """
+
+        LOG.debug("Updating share stats.")
+        backend_name = (self.configuration.safe_get('share_backend_name') or
+                        CONF.share_backend_name)
 
-        LOG.debug("Updating share stats")
-        data = {}
-        backend_name = self.configuration.safe_get('share_backend_name')
         # Note(zhiteng): These information are driver/backend specific,
         # each driver may define these values in its own config options
         # or fetch from driver specific configuration file.
-        data["share_backend_name"] = backend_name or 'Generic_NFS'
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'Open Source'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = None
-
-        data['total_capacity_gb'] = 'infinite'
-        data['free_capacity_gb'] = 'infinite'
-        data['reserved_percentage'] = 0
-        data['QoS_support'] = False
-        self._stats = data
+        common = dict(
+            share_backend_name=backend_name or 'Generic_NFS',
+            driver_handles_share_servers=self.driver_handles_share_servers,
+            vendor_name='Open Source',
+            driver_version='1.0',
+            storage_protocol=None,
+            total_capacity_gb='infinite',
+            free_capacity_gb='infinite',
+            reserved_percentage=0,
+            QoS_support=False)
+        if isinstance(data, dict):
+            common.update(data)
+        self._stats = common
diff --git a/manila/share/drivers/emc/driver.py b/manila/share/drivers/emc/driver.py
index f63f542746..446a381f47 100644
--- a/manila/share/drivers/emc/driver.py
+++ b/manila/share/drivers/emc/driver.py
@@ -63,15 +63,19 @@ CONF.register_opts(EMC_NAS_OPTS)
 class EMCShareDriver(driver.ShareDriver):
     """EMC specific NAS driver. Allows for NFS and CIFS NAS storage usage."""
     def __init__(self, *args, **kwargs):
-        super(EMCShareDriver, self).__init__(*args, **kwargs)
         self.configuration = kwargs.get('configuration', None)
         if self.configuration:
             self.configuration.append_config_values(EMC_NAS_OPTS)
-
+            self.backend_name = self.configuration.safe_get(
+                'emc_share_backend')
+        else:
+            self.backend_name = CONF.emc_share_backend
+        self.backend_name = self.backend_name or 'EMC_NAS_Storage'
         self.plugin_manager = manager.EMCPluginManager(
             namespace='manila.share.drivers.emc.plugins')
-
-        self.plugin = None
+        self.plugin = self.plugin_manager.load_plugin(self.backend_name, LOG)
+        super(EMCShareDriver, self).__init__(
+            self.plugin.driver_handles_share_servers, *args, **kwargs)
 
     def create_share(self, context, share, share_server=None):
         """Is called to create share."""
@@ -122,42 +126,29 @@ class EMCShareDriver(driver.ShareDriver):
 
     def do_setup(self, context):
         """Any initialization the share driver does while starting."""
-        backend_name = self.configuration.safe_get('emc_share_backend')
-
-        self.plugin = self.plugin_manager.load_plugin(backend_name, LOG)
-        self.mode = self.get_driver_mode(self.plugin.supported_driver_modes)
-
         self.plugin.connect(self, context)
 
     def _update_share_stats(self):
         """Retrieve stats info from share."""
 
-        LOG.debug("Updating share stats.")
-        data = {}
         backend_name = self.configuration.safe_get(
             'share_backend_name') or "EMC_NAS_Storage"
-        data["share_backend_name"] = backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'EMC'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS_CIFS'
-
-        data['total_capacity_gb'] = 'infinite'
-        data['free_capacity_gb'] = 'infinite'
-        data['reserved_percentage'] = 0
-        data['QoS_support'] = False
+        data = dict(
+            share_backend_name=backend_name,
+            vendor_name='EMC',
+            storage_protocol='NFS_CIFS')
         self.plugin.update_share_stats(data)
-        self._stats = data
+        super(EMCShareDriver, self)._update_share_stats(data)
 
     def get_network_allocations_number(self):
         """Returns number of network allocations for creating VIFs."""
         return self.plugin.get_network_allocations_number(self)
 
-    def setup_server(self, network_info, metadata=None):
+    def _setup_server(self, network_info, metadata=None):
         """Set up and configures share server with given network parameters."""
         return self.plugin.setup_server(self, network_info, metadata)
 
-    def teardown_server(self, server_details, security_services=None):
+    def _teardown_server(self, server_details, security_services=None):
         """Teardown share server."""
         return self.plugin.teardown_server(self,
                                            server_details,
diff --git a/manila/share/drivers/emc/plugins/base.py b/manila/share/drivers/emc/plugins/base.py
index f25bb1714c..0ec7bfc655 100644
--- a/manila/share/drivers/emc/plugins/base.py
+++ b/manila/share/drivers/emc/plugins/base.py
@@ -25,8 +25,9 @@ class StorageConnection(object):
 
     def __init__(self, logger):
         self.logger = logger
-        # NOTE(vponomaryov): redefine 'supported_driver_modes' within plugin.
-        self.supported_driver_modes = None
+        # NOTE(vponomaryov): redefine 'driver_handles_share_servers' within
+        #                    plugin.
+        self.driver_handles_share_servers = None
 
     @abc.abstractmethod
     def create_share(self, emc_share_driver, context, share, share_server):
diff --git a/manila/share/drivers/emc/plugins/vnx/connection.py b/manila/share/drivers/emc/plugins/vnx/connection.py
index b140b6af26..d8191d1384 100644
--- a/manila/share/drivers/emc/plugins/vnx/connection.py
+++ b/manila/share/drivers/emc/plugins/vnx/connection.py
@@ -17,7 +17,6 @@ from oslo.utils import excutils
 from oslo.utils import units
 import six
 
-from manila.common import constants as const
 from manila import db as manila_db
 from manila import exception
 from manila.i18n import _
@@ -48,7 +47,7 @@ class VNXStorageConnection(driver.StorageConnection):
         self._pool_name = None
         self._pool = None
         self._filesystems = {}
-        self.supported_driver_modes = const.MULTI_SVM_MODE
+        self.driver_handles_share_servers = True
 
     def create_share(self, emc_share_driver, context, share,
                      share_server=None):
diff --git a/manila/share/drivers/generic.py b/manila/share/drivers/generic.py
index 2eab8d08b1..017d319ac5 100644
--- a/manila/share/drivers/generic.py
+++ b/manila/share/drivers/generic.py
@@ -109,12 +109,11 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
 
     def __init__(self, db, *args, **kwargs):
         """Do initialization."""
-        super(GenericShareDriver, self).__init__(*args, **kwargs)
+        super(GenericShareDriver, self).__init__(True, *args, **kwargs)
         self.admin_context = context.get_admin_context()
         self.db = db
         self.configuration.append_config_values(share_opts)
         self.configuration.append_config_values(service_instance.server_opts)
-        self.mode = self.get_driver_mode(const.MULTI_SVM_MODE)
         self._helpers = {}
         self.backend_name = self.configuration.safe_get(
             'share_backend_name') or "Cinder_Volumes"
@@ -450,23 +449,11 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
 
     def _update_share_stats(self):
         """Retrieve stats info from share volume group."""
-
-        LOG.debug("Updating share stats")
-        data = {}
-
-        data["share_backend_name"] = self.backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'Open Source'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS_CIFS'
-
-        data['total_capacity_gb'] = 'infinite'
-        data['free_capacity_gb'] = 'infinite'
-        data['reserved_percentage'] = (self.configuration.
-                                       reserved_share_percentage)
-        data['QoS_support'] = False
-
-        self._stats = data
+        data = dict(
+            share_backend_name=self.backend_name,
+            storage_protocol='NFS_CIFS',
+            reserved_percentage=(self.configuration.reserved_share_percentage))
+        super(GenericShareDriver, self)._update_share_stats(data)
 
     @ensure_server
     def create_share_from_snapshot(self, context, share, snapshot,
@@ -597,7 +584,7 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
         # use service instance provided by Nova.
         return 0
 
-    def setup_server(self, network_info, metadata=None):
+    def _setup_server(self, network_info, metadata=None):
         msg = "Creating share server '%s'."
         LOG.debug(msg % network_info['server_id'])
         server = self.service_instance_manager.set_up_service_instance(
@@ -610,7 +597,7 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
             helper.init_helper(server)
         return server
 
-    def teardown_server(self, server_details, security_services=None):
+    def _teardown_server(self, server_details, security_services=None):
         instance_id = server_details.get("instance_id")
         LOG.debug("Removing share infrastructure for service instance '%s'.",
                   instance_id)
diff --git a/manila/share/drivers/glusterfs.py b/manila/share/drivers/glusterfs.py
index 1eb02ac82e..6e29c6cb62 100644
--- a/manila/share/drivers/glusterfs.py
+++ b/manila/share/drivers/glusterfs.py
@@ -32,7 +32,6 @@ import xml.etree.cElementTree as etree
 from oslo.config import cfg
 import six
 
-from manila.common import constants as const
 from manila import exception
 from manila.i18n import _
 from manila.i18n import _LE
@@ -93,14 +92,13 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
     """Execute commands relating to Shares."""
 
     def __init__(self, db, *args, **kwargs):
-        super(GlusterfsShareDriver, self).__init__(*args, **kwargs)
+        super(GlusterfsShareDriver, self).__init__(False, *args, **kwargs)
         self.db = db
         self._helpers = None
         self.gluster_address = None
         self.configuration.append_config_values(GlusterfsManilaShare_opts)
         self.backend_name = self.configuration.safe_get(
             'share_backend_name') or 'GlusterFS'
-        self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
 
     def do_setup(self, context):
         """Native mount the GlusterFS volume and tune it."""
@@ -242,16 +240,6 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
                                                local_vol_path)
         return os.path.join(local_vol_path, share['name'])
 
-    def get_share_stats(self, refresh=False):
-        """Get share stats.
-
-        If 'refresh' is True, run update the stats first.
-        """
-        if refresh:
-            self._update_share_stats()
-
-        return self._stats
-
     def _update_share_stats(self):
         """Retrieve stats info from the GlusterFS volume."""
 
@@ -264,23 +252,14 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
             )
         smpv = os.statvfs(self._get_mount_point_for_gluster_vol())
 
-        LOG.debug("Updating share stats")
-
-        data = {}
-
-        data["share_backend_name"] = self.backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'Red Hat'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS'
-
-        data['reserved_percentage'] = \
-            self.configuration.reserved_share_percentage
-        data['QoS_support'] = False
-
-        data['total_capacity_gb'] = (smpv.f_blocks * smpv.f_frsize) >> 30
-        data['free_capacity_gb'] = (smpv.f_bavail * smpv.f_frsize) >> 30
-        self._stats = data
+        data = dict(
+            storage_protocol='NFS',
+            vendor_name='Red Hat',
+            share_backend_name=self.backend_name,
+            reserved_percentage=self.configuration.reserved_share_percentage,
+            total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,
+            free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)
+        super(GlusterfsShareDriver, self)._update_share_stats(data)
 
     def get_network_allocations_number(self):
         return 0
diff --git a/manila/share/drivers/glusterfs_native.py b/manila/share/drivers/glusterfs_native.py
index 3140b6b168..b8e9418cb9 100644
--- a/manila/share/drivers/glusterfs_native.py
+++ b/manila/share/drivers/glusterfs_native.py
@@ -33,7 +33,6 @@ import tempfile
 from oslo.config import cfg
 import six
 
-from manila.common import constants as const
 from manila import exception
 from manila.i18n import _
 from manila.i18n import _LI
@@ -76,7 +75,8 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
     """
 
     def __init__(self, db, *args, **kwargs):
-        super(GlusterfsNativeShareDriver, self).__init__(*args, **kwargs)
+        super(GlusterfsNativeShareDriver, self).__init__(
+            False, *args, **kwargs)
         self.db = db
         self._helpers = None
         self.gluster_unused_vols_dict = {}
@@ -85,7 +85,6 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
             glusterfs_native_manila_share_opts)
         self.backend_name = self.configuration.safe_get(
             'share_backend_name') or 'GlusterFS-Native'
-        self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
 
     def do_setup(self, context):
         """Setup the GlusterFS volumes."""
@@ -489,32 +488,15 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
         # set dynamically.
         self._restart_gluster_vol(gluster_addr)
 
-    def get_share_stats(self, refresh=False):
-        """Get share stats.
-
-        If 'refresh' is True, update the stats first.
-        """
-        if refresh:
-            self._update_share_stats()
-
-        return self._stats
-
     def _update_share_stats(self):
         """Send stats info for the GlusterFS volume."""
 
-        LOG.debug("Updating share stats")
-
-        data = {}
-
-        data["share_backend_name"] = self.backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'Red Hat'
-        data["driver_version"] = '1.1'
-        data["storage_protocol"] = 'glusterfs'
-
-        data['reserved_percentage'] = (
-            self.configuration.reserved_share_percentage)
-        data['QoS_support'] = False
+        data = dict(
+            share_backend_name=self.backend_name,
+            vendor_name='Red Hat',
+            driver_version='1.1',
+            storage_protocol='glusterfs',
+            reserved_percentage=self.configuration.reserved_share_percentage)
 
         # We don't use a service mount to get stats data.
         # Instead we use glusterfs quota feature and use that to limit
@@ -524,7 +506,8 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
         # specific stats via the gluster cli.
         data['total_capacity_gb'] = 'infinite'
         data['free_capacity_gb'] = 'infinite'
-        self._stats = data
+
+        super(GlusterfsNativeShareDriver, self)._update_share_stats(data)
 
     def ensure_share(self, context, share, share_server=None):
         """Invoked to ensure that share is exported."""
diff --git a/manila/share/drivers/huawei/huawei_nas.py b/manila/share/drivers/huawei/huawei_nas.py
index 1a299f11f4..6c9e673ab3 100644
--- a/manila/share/drivers/huawei/huawei_nas.py
+++ b/manila/share/drivers/huawei/huawei_nas.py
@@ -20,7 +20,6 @@ from oslo.config import cfg
 from oslo.utils import excutils
 from oslo.utils import units
 
-from manila.common import constants as const
 from manila import exception
 from manila.i18n import _, _LI, _LW
 from manila.openstack.common import log as logging
@@ -51,14 +50,13 @@ class HuaweiNasDriver(driver.ShareDriver):
     def __init__(self, *args, **kwargs):
         """Do initialization."""
         LOG.debug("Enter into init function.")
-        super(HuaweiNasDriver, self).__init__(*args, **kwargs)
+        super(HuaweiNasDriver, self).__init__(False, *args, **kwargs)
         self.configuration = kwargs.get('configuration', None)
         if self.configuration:
             self.configuration.append_config_values(huawei_opts)
             self.helper = huawei_helper.RestHelper(self.configuration)
         else:
             raise exception.InvalidShare(_("Huawei configuration missing."))
-        self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
 
     def check_for_setup_error(self):
         """Returns an error if prerequisites aren't met."""
@@ -112,13 +110,6 @@ class HuaweiNasDriver(driver.ShareDriver):
 
         return location
 
-    def get_share_stats(self, refresh=False):
-        """Get a share stats."""
-        LOG.debug("Get a share stats.")
-        data = self._update_share_stats()
-
-        return data
-
     def create_share_from_snapshot(self, context, share, snapshot,
                                    share_server=None):
         """Is called to create share from snapshot."""
@@ -195,28 +186,15 @@ class HuaweiNasDriver(driver.ShareDriver):
     def _update_share_stats(self):
         """Retrieve status info from share group."""
 
-        capacity = self.helper._get_capacity()
-
-        # Note(zhiteng): These information are driver/backend specific,
-        # each driver may define these values in its own config options
-        # or fetch from driver specific configuration file.
-        data = {}
-
         backend_name = self.configuration.safe_get('share_backend_name')
-
-        data["share_backend_name"] = backend_name or 'HUAWEI_NAS_Driver'
-        data["vendor_name"] = 'Huawei'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS_CIFS'
-
-        data['total_capacity_gb'] = capacity['total_capacity']
-        data['free_capacity_gb'] = capacity['free_capacity']
-
-        data['reserved_percentage'] = 0
-        data["share_driver_mode"] = self.mode
-        data['QoS_support'] = False
-
-        return data
+        capacity = self.helper._get_capacity()
+        data = dict(
+            share_backend_name=backend_name or 'HUAWEI_NAS_Driver',
+            vendor_name='Huawei',
+            storage_protocol='NFS_CIFS',
+            total_capacity_gb=capacity['total_capacity'],
+            free_capacity_gb=capacity['free_capacity'])
+        super(HuaweiNasDriver, self)._update_share_stats(data)
 
     def _get_wait_interval(self):
         """Get wait interval from huawei conf file."""
diff --git a/manila/share/drivers/ibm/gpfs.py b/manila/share/drivers/ibm/gpfs.py
index fdb1dcb9bb..67fd3f1bf2 100644
--- a/manila/share/drivers/ibm/gpfs.py
+++ b/manila/share/drivers/ibm/gpfs.py
@@ -43,7 +43,6 @@ from oslo.utils import units
 from oslo_concurrency import processutils
 import six
 
-from manila.common import constants as const
 from manila import exception
 from manila.i18n import _, _LE, _LI
 from manila.openstack.common import log as logging
@@ -124,13 +123,12 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
 
     def __init__(self, db, *args, **kwargs):
         """Do initialization."""
-        super(GPFSShareDriver, self).__init__(*args, **kwargs)
+        super(GPFSShareDriver, self).__init__(False, *args, **kwargs)
         self.db = db
         self._helpers = {}
         self.configuration.append_config_values(gpfs_share_opts)
         self.backend_name = self.configuration.safe_get(
             'share_backend_name') or "IBM Storage System"
-        self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
         self.sshpool = None
         self.ssh_connections = {}
         self._gpfs_execute = None
@@ -499,18 +497,11 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
     def _update_share_stats(self):
         """Retrieve stats info from share volume group."""
 
-        LOG.debug("Updating share stats")
-        data = {}
-
-        data["share_backend_name"] = self.backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'IBM'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS'
-
-        data['reserved_percentage'] = \
-            self.configuration.reserved_share_percentage
-        data['QoS_support'] = False
+        data = dict(
+            share_backend_name=self.backend_name,
+            vendor_name='IBM',
+            storage_protocol='NFS',
+            reserved_percentage=self.configuration.reserved_share_percentage)
 
         free, capacity = self._get_available_capacity(
             self.configuration.gpfs_mount_point_base)
@@ -518,7 +509,7 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
         data['total_capacity_gb'] = math.ceil(capacity / units.Gi)
         data['free_capacity_gb'] = math.ceil(free / units.Gi)
 
-        self._stats = data
+        super(GPFSShareDriver, self)._update_share_stats(data)
 
     def _get_helper(self, share):
         if share['share_proto'].startswith('NFS'):
diff --git a/manila/share/drivers/netapp/cluster_mode.py b/manila/share/drivers/netapp/cluster_mode.py
index 01d2d5b8d7..3aadf504d7 100644
--- a/manila/share/drivers/netapp/cluster_mode.py
+++ b/manila/share/drivers/netapp/cluster_mode.py
@@ -28,7 +28,6 @@ from oslo.utils import excutils
 from oslo.utils import units
 import six
 
-from manila.common import constants as const
 from manila import context
 from manila import exception
 from manila.i18n import _
@@ -135,7 +134,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
     """
 
     def __init__(self, db, *args, **kwargs):
-        super(NetAppClusteredShareDriver, self).__init__(*args, **kwargs)
+        super(NetAppClusteredShareDriver, self).__init__(True, *args, **kwargs)
         self.db = db
         self._helpers = None
         self._licenses = []
@@ -145,7 +144,6 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
         self.api_version = (1, 15)
         self.backend_name = self.configuration.safe_get(
             'share_backend_name') or "NetApp_Cluster_Mode"
-        self.mode = self.get_driver_mode(const.MULTI_SVM_MODE)
 
     def do_setup(self, context):
         """Prepare once the driver.
@@ -192,23 +190,14 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
 
     def _update_share_stats(self):
         """Retrieve stats info from Cluster Mode backend."""
-
-        LOG.debug("Updating share stats")
-        data = {}
-        data["share_backend_name"] = self.backend_name
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'NetApp'
-        data["driver_version"] = '1.0'
-        data["storage_protocol"] = 'NFS_CIFS'
-
         total, free = self._calculate_capacity()
-        data['total_capacity_gb'] = total / units.Gi
-        data['free_capacity_gb'] = free / units.Gi
-
-        data['reserved_percentage'] = 0
-        data['QoS_support'] = False
-
-        self._stats = data
+        data = dict(
+            share_backend_name=self.backend_name,
+            vendor_name='NetApp',
+            storage_protocol='NFS_CIFS',
+            total_capacity_gb=(total / units.Gi),
+            free_capacity_gb=(free / units.Gi))
+        super(NetAppClusteredShareDriver, self)._update_share_stats(data)
 
     def check_for_setup_error(self):
         """Raises error if prerequisites are not met."""
@@ -228,7 +217,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
                     for aggr in aggr_space_attrs])
         return total, free
 
-    def setup_server(self, network_info, metadata=None):
+    def _setup_server(self, network_info, metadata=None):
         """Creates and configures new vserver."""
         LOG.debug('Creating server %s', network_info['server_id'])
         vserver_name = self._vserver_create_if_not_exists(network_info)
@@ -866,7 +855,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
         self._client.send_request('vserver-destroy',
                                   {'vserver-name': vserver_name})
 
-    def teardown_server(self, server_details, security_services=None):
+    def _teardown_server(self, server_details, security_services=None):
         """Teardown share network."""
         vserver_name = server_details['vserver_name']
         vserver_client = NetAppApiClient(
diff --git a/manila/share/drivers/zfssa/zfssashare.py b/manila/share/drivers/zfssa/zfssashare.py
index ac167b5d1b..22ceba93ea 100644
--- a/manila/share/drivers/zfssa/zfssashare.py
+++ b/manila/share/drivers/zfssa/zfssashare.py
@@ -20,7 +20,6 @@ import base64
 from oslo.config import cfg
 from oslo.utils import units
 
-from manila.common import constants as const
 from manila import exception
 from manila.i18n import _
 from manila.i18n import _LE
@@ -81,8 +80,8 @@ class ZFSSAShareDriver(driver.ShareDriver):
     VERSION = '1.0.0'
     PROTOCOL = 'NFS_CIFS'
 
-    def __init__(self, *args, **kwargs):
-        super(ZFSSAShareDriver, self).__init__(*args, **kwargs)
+    def __init__(self, False, *args, **kwargs):
+        super(ZFSSAShareDriver, self).__init__(False, *args, **kwargs)
         self.configuration.append_config_values(ZFSSA_OPTS)
         self.zfssa = None
         self._stats = None
@@ -122,7 +121,6 @@ class ZFSSAShareDriver(driver.ShareDriver):
             'quota_snap': self.configuration.zfssa_nas_quota_snap,
             'reservation_snap': self.configuration.zfssa_nas_quota_snap,
         }
-        self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
 
     def do_setup(self, context):
         """Login, create project, no sharing option enabled."""
@@ -303,14 +301,12 @@ class ZFSSAShareDriver(driver.ShareDriver):
 
     def _update_share_stats(self):
         """Retrieve stats info from a share."""
-        LOG.debug("Updating share stats...")
-        data = {}
         backend_name = self.configuration.safe_get('share_backend_name')
-        data["share_backend_name"] = backend_name or self.__class__.__name__
-        data["share_driver_mode"] = self.mode
-        data["vendor_name"] = 'Oracle'
-        data["driver_version"] = self.VERSION
-        data["storage_protocol"] = self.PROTOCOL
+        data = dict(
+            share_backend_name=backend_name or self.__class__.__name__,
+            vendor_name='Oracle',
+            driver_version=self.VERSION,
+            storage_protocol=self.PROTOCOL)
 
         lcfg = self.configuration
         (avail, used) = self.zfssa.get_pool_stats(lcfg.zfssa_pool)
@@ -325,9 +321,7 @@ class ZFSSAShareDriver(driver.ShareDriver):
             data['free_capacity_gb'] = 0
             data['total_capacity_gb'] = 0
 
-        data['reserved_percentage'] = 0
-        data['QoS_support'] = False
-        self._stats = data
+        super(ZFSSAShareDriver, self)._update_share_stats(data)
 
     def get_network_allocations_number(self):
         """Returns number of network allocations for creating VIFs."""
diff --git a/manila/share/manager.py b/manila/share/manager.py
index d890e887b8..a993dbc169 100644
--- a/manila/share/manager.py
+++ b/manila/share/manager.py
@@ -197,11 +197,11 @@ class ShareManager(manager.SchedulerDependentManager):
         share_ref = self.db.share_get(context, share_id)
         share_network_id = share_ref.get('share_network_id', None)
 
-        if share_network_id and self.driver.mode == constants.SINGLE_SVM_MODE:
+        if share_network_id and not self.driver.driver_handles_share_servers:
             self.db.share_update(context, share_id, {'status': 'error'})
             raise exception.ManilaException(
-                "Driver with single SVM mode does not expect share-network "
-                "to be provided.")
+                "Driver does not expect share-network to be provided "
+                "with current configuration.")
 
         if snapshot_id is not None:
             snapshot_ref = self.db.share_snapshot_get(context, snapshot_id)
diff --git a/manila/tests/fake_driver.py b/manila/tests/fake_driver.py
index 653f3b74cc..94b5a96db0 100644
--- a/manila/tests/fake_driver.py
+++ b/manila/tests/fake_driver.py
@@ -15,7 +15,6 @@
 
 import mock
 
-from manila.common import constants
 from manila.openstack.common import log as logging
 from manila.share import driver
 
@@ -26,10 +25,8 @@ class FakeShareDriver(driver.ShareDriver):
     """Fake share driver."""
 
     def __init__(self, *args, **kwargs):
-        super(FakeShareDriver, self).__init__(execute=self.fake_execute,
-                                              *args, **kwargs)
+        super(FakeShareDriver, self).__init__(True, *args, **kwargs)
         self.db = mock.Mock()
-        self.mode = constants.MULTI_SVM_MODE
 
         def share_network_update(*args, **kwargs):
             pass
@@ -37,6 +34,12 @@ class FakeShareDriver(driver.ShareDriver):
         self.db.share_network_update = mock.Mock(
             side_effect=share_network_update)
 
+    @property
+    def driver_handles_share_servers(self):
+        if not isinstance(self.configuration.safe_get(
+                'driver_handles_share_servers'), bool):
+            return True
+
     def create_snapshot(self, context, snapshot, share_server=None):
         pass
 
@@ -81,9 +84,3 @@ class FakeShareDriver(driver.ShareDriver):
         # NOTE(vponomaryov): Simulate drivers that use share servers and
         # do not use 'service_instance' module.
         return 2
-
-    @staticmethod
-    def fake_execute(cmd, *_args, **_kwargs):
-        """Execute that simply logs the command."""
-        LOG.debug("FAKE EXECUTE: %s", cmd)
-        return (None, None)
diff --git a/manila/tests/share/drivers/emc/test_driver.py b/manila/tests/share/drivers/emc/test_driver.py
index 11ea4e1b39..3758ad1c37 100644
--- a/manila/tests/share/drivers/emc/test_driver.py
+++ b/manila/tests/share/drivers/emc/test_driver.py
@@ -16,7 +16,6 @@
 import mock
 from stevedore import extension
 
-from manila.common import constants as const
 from manila.openstack.common import log as logging
 from manila.share import configuration as conf
 from manila.share.drivers.emc import driver as emcdriver
@@ -29,7 +28,10 @@ LOG = logging.getLogger(__name__)
 class FakeConnection(base.StorageConnection):
     def __init__(self, logger):
         self.logger = logger
-        self.supported_driver_modes = const.MULTI_SVM_MODE
+
+    @property
+    def driver_handles_share_servers(self):
+        return True
 
     def create_share(self, emc_share_driver, context, share, share_server):
         """Is called to create share."""
@@ -125,7 +127,7 @@ class EMCShareFrameworkTestCase(test.TestCase):
         self.driver.plugin = mock.Mock()
         self.driver._update_share_stats()
         data["share_backend_name"] = FAKE_BACKEND
-        data["share_driver_mode"] = self.driver.mode
+        data["driver_handles_share_servers"] = True
         data["vendor_name"] = 'EMC'
         data["driver_version"] = '1.0'
         data["storage_protocol"] = 'NFS_CIFS'
@@ -133,9 +135,11 @@ class EMCShareFrameworkTestCase(test.TestCase):
         data['free_capacity_gb'] = 'infinite'
         data['reserved_percentage'] = 0
         data['QoS_support'] = False
-        self.driver.plugin.update_share_stats.assert_called_with(data)
+        self.assertEqual(data, self.driver._stats)
 
     def _fake_safe_get(self, value):
         if value in ['emc_share_backend', 'share_backend_name']:
             return FAKE_BACKEND
+        elif value == 'driver_handles_share_servers':
+            return True
         return None
diff --git a/manila/tests/share/drivers/emc/test_emc_vnx.py b/manila/tests/share/drivers/emc/test_emc_vnx.py
index ca8720df03..61f56165e1 100644
--- a/manila/tests/share/drivers/emc/test_emc_vnx.py
+++ b/manila/tests/share/drivers/emc/test_emc_vnx.py
@@ -1650,4 +1650,6 @@ class EMCShareDriverVNXTestCase(test.TestCase):
     def _fake_safe_get(self, value):
         if value == "emc_share_backend":
             return "vnx"
+        elif value == 'driver_handles_share_servers':
+            return True
         return None
diff --git a/manila/tests/share/drivers/huawei/test_huawei_nas.py b/manila/tests/share/drivers/huawei/test_huawei_nas.py
index b1f3f649e0..da85043515 100644
--- a/manila/tests/share/drivers/huawei/test_huawei_nas.py
+++ b/manila/tests/share/drivers/huawei/test_huawei_nas.py
@@ -25,7 +25,6 @@ import xml.dom.minidom
 import mock
 from oslo.serialization import jsonutils
 
-from manila.common import constants as const
 from manila import context
 from manila import exception
 from manila.share import configuration as conf
@@ -257,7 +256,7 @@ class HuaweiShareDriverTestCase(test.TestCase):
         self.configuration.safe_get = mock.Mock(side_effect=_safe_get)
         self.configuration.network_config_group = 'fake_network_config_group'
         self.configuration.share_backend_name = 'fake_share_backend_name'
-        self.configuration.share_driver_mode = const.SINGLE_SVM_MODE
+        self.configuration.driver_handles_share_servers = False
         self.configuration.manila_huawei_conf_file = self.fake_conf_file
         self.stubs.Set(time, 'sleep', fake_sleep)
         driver = FakeHuaweiNasDriver(configuration=self.configuration)
@@ -421,13 +420,20 @@ class HuaweiShareDriverTestCase(test.TestCase):
                                  self.share_server)
         self.assertTrue(self.driver.helper.delete_flag)
 
-    def test_get_share_stats(self):
+    def test_get_share_stats_refresh_false(self):
+        self.driver._stats = {'fake_key': 'fake_value'}
+
+        result = self.driver.get_share_stats(False)
+
+        self.assertEqual(self.driver._stats, result)
+
+    def test_get_share_stats_refresh_true(self):
         self.driver.helper.login()
-        data = self.driver.get_share_stats()
+        data = self.driver.get_share_stats(True)
 
         expected = {}
         expected["share_backend_name"] = "fake_share_backend_name"
-        expected["share_driver_mode"] = self.driver.mode
+        expected["driver_handles_share_servers"] = False
         expected["vendor_name"] = 'Huawei'
         expected["driver_version"] = '1.0'
         expected["storage_protocol"] = 'NFS_CIFS'
diff --git a/manila/tests/share/drivers/ibm/test_gpfs.py b/manila/tests/share/drivers/ibm/test_gpfs.py
index b4b4f0ec1d..119dae305b 100644
--- a/manila/tests/share/drivers/ibm/test_gpfs.py
+++ b/manila/tests/share/drivers/ibm/test_gpfs.py
@@ -79,6 +79,7 @@ class GPFSShareDriverTestCase(test.TestCase):
         self._gpfs_execute = mock.Mock(return_value=('', ''))
 
         self._helper_fake = mock.Mock()
+        CONF.set_default('driver_handles_share_servers', False)
         self.fake_conf = config.Configuration(None)
         self._db = mock.Mock()
         self._driver = gpfs.GPFSShareDriver(self._db,
@@ -140,12 +141,13 @@ class GPFSShareDriverTestCase(test.TestCase):
         result = self._driver.get_share_stats(True)
         expected_keys = [
             'QoS_support', 'driver_version', 'share_backend_name',
-            'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
+            'free_capacity_gb', 'total_capacity_gb',
+            'driver_handles_share_servers',
             'reserved_percentage', 'vendor_name', 'storage_protocol',
         ]
         for key in expected_keys:
             self.assertIn(key, result)
-        self.assertEqual(self._driver.mode, result['share_driver_mode'])
+        self.assertEqual(False, result['driver_handles_share_servers'])
         self.assertEqual('IBM', result['vendor_name'])
         self._driver._get_available_capacity.assert_called_once_with(
             self._driver.configuration.gpfs_mount_point_base)
diff --git a/manila/tests/share/drivers/netapp/test_cluster_mode.py b/manila/tests/share/drivers/netapp/test_cluster_mode.py
index 90a1259d6b..d8e4987b72 100644
--- a/manila/tests/share/drivers/netapp/test_cluster_mode.py
+++ b/manila/tests/share/drivers/netapp/test_cluster_mode.py
@@ -34,6 +34,7 @@ class NetAppClusteredDrvTestCase(test.TestCase):
         super(NetAppClusteredDrvTestCase, self).setUp()
         self._context = context.get_admin_context()
         self._db = mock.Mock()
+        driver.CONF.set_default('driver_handles_share_servers', True)
         self.driver = driver.NetAppClusteredShareDriver(
             self._db, configuration=configuration.Configuration(None))
         self.driver._client = mock.Mock()
@@ -140,7 +141,7 @@ class NetAppClusteredDrvTestCase(test.TestCase):
 
         expected = {}
         expected["share_backend_name"] = self.driver.backend_name
-        expected["share_driver_mode"] = self.driver.mode
+        expected["driver_handles_share_servers"] = True
         expected["vendor_name"] = 'NetApp'
         expected["driver_version"] = '1.0'
         expected["storage_protocol"] = 'NFS_CIFS'
diff --git a/manila/tests/share/drivers/test_generic.py b/manila/tests/share/drivers/test_generic.py
index c1c0dbffaf..3aa7fb66fc 100644
--- a/manila/tests/share/drivers/test_generic.py
+++ b/manila/tests/share/drivers/test_generic.py
@@ -88,6 +88,7 @@ class GenericShareDriverTestCase(test.TestCase):
 
         self._helper_cifs = mock.Mock()
         self._helper_nfs = mock.Mock()
+        CONF.set_default('driver_handles_share_servers', True)
         self.fake_conf = manila.share.configuration.Configuration(None)
         self._db = mock.Mock()
         with mock.patch.object(
@@ -944,7 +945,8 @@ class GenericShareDriverTestCase(test.TestCase):
         self._driver._stats = fake_stats
         expected_keys = [
             'QoS_support', 'driver_version', 'share_backend_name',
-            'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
+            'free_capacity_gb', 'total_capacity_gb',
+            'driver_handles_share_servers',
             'reserved_percentage', 'vendor_name', 'storage_protocol',
         ]
 
@@ -953,37 +955,9 @@ class GenericShareDriverTestCase(test.TestCase):
         self.assertNotEqual(fake_stats, result)
         for key in expected_keys:
             self.assertIn(key, result)
-        self.assertEqual(self._driver.mode, result['share_driver_mode'])
+        self.assertEqual(True, result['driver_handles_share_servers'])
         self.assertEqual('Open Source', result['vendor_name'])
 
-    @mock.patch.object(
-        generic.service_instance, 'ServiceInstanceManager', mock.Mock())
-    def test_driver_mode_valid_value(self):
-        mode = const.MULTI_SVM_MODE
-        CONF.set_override('share_driver_mode', mode)
-
-        driver = generic.GenericShareDriver(
-            self._db, execute=self._execute, configuration=self.fake_conf)
-
-        self.assertEqual(mode, driver.mode)
-        generic.service_instance.ServiceInstanceManager.\
-            assert_called_once_with(self._db, driver_config=self.fake_conf)
-
-    def test_driver_mode_invalid_value(self):
-        mode = const.SINGLE_SVM_MODE
-        CONF.set_override('share_driver_mode', mode)
-
-        self.assertRaises(
-            exception.InvalidParameterValue,
-            generic.GenericShareDriver,
-            self._db,
-            execute=self._execute,
-            configuration=self.fake_conf)
-
-    def test_driver_mode_default_share_driver_modes(self):
-        mode = const.MULTI_SVM_MODE
-        self.assertEqual(mode, self._driver.mode)
-
 
 class NFSHelperTestCase(test.TestCase):
     """Test case for NFS helper of generic driver."""
diff --git a/manila/tests/share/drivers/test_glusterfs.py b/manila/tests/share/drivers/test_glusterfs.py
index d994b9a94f..0bdff9b9ba 100644
--- a/manila/tests/share/drivers/test_glusterfs.py
+++ b/manila/tests/share/drivers/test_glusterfs.py
@@ -116,6 +116,7 @@ class GlusterfsShareDriverTestCase(test.TestCase):
         CONF.set_default('glusterfs_target', '127.0.0.1:/testvol')
         CONF.set_default('glusterfs_mount_point_base', '/mnt/nfs')
         CONF.set_default('reserved_share_percentage', 50)
+        CONF.set_default('driver_handles_share_servers', False)
 
         self.fake_conf = config.Configuration(None)
         self._db = mock.Mock()
@@ -447,7 +448,7 @@ class GlusterfsShareDriverTestCase(test.TestCase):
     def test_update_share_stats(self):
         test_data = {
             'share_backend_name': 'GlusterFS',
-            'share_driver_mode': self._driver.mode,
+            'driver_handles_share_servers': False,
             'vendor_name': 'Red Hat',
             'driver_version': '1.0',
             'storage_protocol': 'NFS',
diff --git a/manila/tests/share/drivers/test_glusterfs_native.py b/manila/tests/share/drivers/test_glusterfs_native.py
index b2b29c7b60..24f99c2be2 100644
--- a/manila/tests/share/drivers/test_glusterfs_native.py
+++ b/manila/tests/share/drivers/test_glusterfs_native.py
@@ -85,6 +85,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase):
         self.gluster_target2 = 'root@host2:/gv2'
         CONF.set_default('glusterfs_targets',
                          [self.gluster_target1, self.gluster_target2])
+        CONF.set_default('driver_handles_share_servers', False)
 
         self.fake_conf = config.Configuration(None)
         self._db = mock.Mock()
@@ -792,7 +793,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase):
     def test_update_share_stats(self):
         test_data = {
             'share_backend_name': 'GlusterFS-Native',
-            'share_driver_mode': self._driver.mode,
+            'driver_handles_share_servers': False,
             'vendor_name': 'Red Hat',
             'driver_version': '1.1',
             'storage_protocol': 'glusterfs',
diff --git a/manila/tests/share/drivers/zfssa/test_zfssashare.py b/manila/tests/share/drivers/zfssa/test_zfssashare.py
index 51d5f7262c..d7c969759c 100644
--- a/manila/tests/share/drivers/zfssa/test_zfssashare.py
+++ b/manila/tests/share/drivers/zfssa/test_zfssashare.py
@@ -17,7 +17,6 @@ Unit tests for Oracle's ZFSSA Manila driver.
 import mock
 from oslo.config import cfg
 
-from manila.common import constants as const
 from manila import context
 from manila import exception
 from manila.share import configuration as conf
@@ -67,7 +66,7 @@ class ZFSSAShareDriverTestCase(test.TestCase):
         _factory_zfssa.set_host(lcfg.zfssa_host)
         _factory_zfssa.login(lcfg.zfssa_auth_user)
         self._context = context.get_admin_context()
-        self._driver = zfssashare.ZFSSAShareDriver(configuration=lcfg)
+        self._driver = zfssashare.ZFSSAShareDriver(False, configuration=lcfg)
         self._driver.do_setup(self._context)
 
     def _create_fake_config(self):
@@ -91,7 +90,7 @@ class ZFSSAShareDriverTestCase(test.TestCase):
         self.configuration.zfssa_nas_quota_snap = 'true'
         self.configuration.zfssa_rest_timeout = 60
         self.configuration.network_config_group = 'fake_network_config_group'
-        self.configuration.share_driver_mode = const.SINGLE_SVM_MODE
+        self.configuration.driver_handles_share_servers = False
 
     def test_create_share(self):
         self.stubs.Set(self._driver.zfssa, 'create_share', mock.Mock())
diff --git a/manila/tests/share/test_driver.py b/manila/tests/share/test_driver.py
index 546e2d5428..e07b2207e7 100644
--- a/manila/tests/share/test_driver.py
+++ b/manila/tests/share/test_driver.py
@@ -21,7 +21,6 @@ import time
 import ddt
 import mock
 
-from manila.common import constants
 from manila import exception
 from manila import network
 from manila.share import configuration
@@ -51,22 +50,20 @@ class ShareDriverTestCase(test.TestCase):
         self.stubs.Set(self.utils, 'execute', fake_execute_with_raise)
         self.time = time
         self.stubs.Set(self.time, 'sleep', fake_sleep)
-
-        self.fake_valid_modes = ('v1', 'v2', )
-        self.stubs.Set(
-            constants, 'VALID_SHARE_DRIVER_MODES', self.fake_valid_modes)
+        self.stubs.Set(driver.CONF, 'driver_handles_share_servers', True)
 
     def test__try_execute(self):
         execute_mixin = ShareDriverWithExecuteMixin(
-            configuration=configuration.Configuration(None))
+            True, configuration=configuration.Configuration(None))
         self.assertRaises(exception.ProcessExecutionError,
                           execute_mixin._try_execute)
 
     def test_verify_share_driver_mode_option_type(self):
+        opt_name = 'driver_handles_share_servers'
         with utils.tempdir() as tmpdir:
-            tmpfilename = os.path.join(tmpdir, 'share_driver_mode.conf')
+            tmpfilename = os.path.join(tmpdir, '%s.conf' % opt_name)
             with open(tmpfilename, "w") as configfile:
-                configfile.write("""[DEFAULT]\nshare_driver_mode = fake""")
+                configfile.write("""[DEFAULT]\n%s = True""" % opt_name)
 
             # Add config file with updated opt
             driver.CONF.default_config_files = [configfile.name]
@@ -74,17 +71,19 @@ class ShareDriverTestCase(test.TestCase):
             # Reload config instance to use redefined opt
             driver.CONF.reload_config_files()
 
-            share_driver = driver.ShareDriver()
-            self.assertEqual('fake', share_driver.mode)
+            share_driver = driver.ShareDriver([True, False])
+            self.assertEqual(True, share_driver.driver_handles_share_servers)
 
-    def _instantiate_share_driver(self, network_config_group):
+    def _instantiate_share_driver(self, network_config_group,
+                                  driver_handles_share_servers):
         self.stubs.Set(network, 'API', mock.Mock())
         config = mock.Mock()
         config.append_config_values = mock.Mock()
         config.config_group = 'fake_config_group'
         config.network_config_group = network_config_group
+        config.safe_get = mock.Mock(return_value=driver_handles_share_servers)
 
-        share_driver = driver.ShareDriver(configuration=config)
+        share_driver = driver.ShareDriver([True, False], configuration=config)
 
         self.assertTrue(hasattr(share_driver, 'configuration'))
         config.append_config_values.assert_called_once_with(driver.share_opts)
@@ -94,25 +93,24 @@ class ShareDriverTestCase(test.TestCase):
         else:
             network.API.assert_called_once_with(
                 config_group_name=config.config_group)
-        self.assertTrue(hasattr(share_driver, 'mode'))
         return share_driver
 
     def test_instantiate_share_driver(self):
-        self._instantiate_share_driver(None)
+        self._instantiate_share_driver(None, True)
 
     def test_instantiate_share_driver_another_config_group(self):
-        self._instantiate_share_driver("fake_network_config_group")
+        self._instantiate_share_driver("fake_network_config_group", True)
 
     def test_instantiate_share_driver_no_configuration(self):
         self.stubs.Set(network, 'API', mock.Mock())
 
-        share_driver = driver.ShareDriver(configuration=None)
+        share_driver = driver.ShareDriver(True, configuration=None)
 
         self.assertEqual(None, share_driver.configuration)
         network.API.assert_called_once_with(config_group_name=None)
 
     def test_get_share_stats_refresh_false(self):
-        share_driver = driver.ShareDriver(configuration=None)
+        share_driver = driver.ShareDriver(True, configuration=None)
         share_driver._stats = {'fake_key': 'fake_value'}
 
         result = share_driver.get_share_stats(False)
@@ -123,10 +121,11 @@ class ShareDriverTestCase(test.TestCase):
         conf = configuration.Configuration(None)
         expected_keys = [
             'QoS_support', 'driver_version', 'share_backend_name',
-            'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
+            'free_capacity_gb', 'total_capacity_gb',
+            'driver_handles_share_servers',
             'reserved_percentage', 'vendor_name', 'storage_protocol',
         ]
-        share_driver = driver.ShareDriver(configuration=conf)
+        share_driver = driver.ShareDriver(True, configuration=conf)
         fake_stats = {'fake_key': 'fake_value'}
         share_driver._stats = fake_stats
 
@@ -138,53 +137,61 @@ class ShareDriverTestCase(test.TestCase):
         self.assertEqual('Open Source', result['vendor_name'])
 
     @ddt.data(
-        '', 'v1', 'v2', 'fake1', None,
-        [], ['v1'], ['v2'], ['v1', 'v2'], ['fake1'], ['fake1', 'fake2'],
-        (), ('v1'), ('v2'), ('v1', 'v2'), ('fake1', ), ('fake1', 'fake2'))
-    def test_get_driver_mode_invalid_opt(self, driver_modes):
-        share_driver = self._instantiate_share_driver(None)
-        share_driver.mode = 'fake'
-        self.assertRaises(
-            exception.InvalidParameterValue,
-            share_driver.get_driver_mode, driver_modes)
+        {'opt': True, 'allowed': True},
+        {'opt': True, 'allowed': (True, False)},
+        {'opt': True, 'allowed': [True, False]},
+        {'opt': True, 'allowed': set([True, False])},
+        {'opt': False, 'allowed': False},
+        {'opt': False, 'allowed': (True, False)},
+        {'opt': False, 'allowed': [True, False]},
+        {'opt': False, 'allowed': set([True, False])})
+    @ddt.unpack
+    def test__verify_share_server_handling_valid_cases(self, opt, allowed):
+        conf = configuration.Configuration(None)
+        self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt))
+        share_driver = driver.ShareDriver(allowed, configuration=conf)
+        self.assertTrue(conf.safe_get.celled)
+        self.assertEqual(opt, share_driver.driver_handles_share_servers)
 
     @ddt.data(
-        (), [], ('v1', 'v2'), ['v1', 'v2'], ('v1', 'fake1'), ['v1', 'fake1'],
-        ('fake1', 'fake2'), ['fake1', 'fake2'], ('fake1', ), ['fake1'], '',
-        'fake1', {}, {'v1': 'v2'}, None)
-    def test_get_driver_mode_none_opt_invalid_cases(self, driver_modes):
-        share_driver = self._instantiate_share_driver(None)
-        share_driver.mode = None
+        {'opt': False, 'allowed': True},
+        {'opt': True, 'allowed': False},
+        {'opt': None, 'allowed': True},
+        {'opt': 'True', 'allowed': True},
+        {'opt': 'False', 'allowed': False},
+        {'opt': [], 'allowed': True},
+        {'opt': True, 'allowed': []},
+        {'opt': True, 'allowed': ['True']},
+        {'opt': False, 'allowed': ['False']})
+    @ddt.unpack
+    def test__verify_share_server_handling_invalid_cases(self, opt, allowed):
+        conf = configuration.Configuration(None)
+        self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt))
         self.assertRaises(
-            exception.InvalidParameterValue,
-            share_driver.get_driver_mode, driver_modes)
+            exception.ManilaException,
+            driver.ShareDriver, allowed, configuration=conf)
+        self.assertTrue(conf.safe_get.celled)
 
-    @ddt.data('v2', ('v2', ), ['v2', ])
-    def test_get_driver_mode_none_opt_valid_cases(self, driver_modes):
-        share_driver = self._instantiate_share_driver(None)
-        share_driver.mode = None
+    def test_setup_server_handling_disabled(self):
+        share_driver = self._instantiate_share_driver(None, False)
+        # We expect successful execution, nothing to assert
+        share_driver.setup_server('Nothing is expected to happen.')
 
-        mode = share_driver.get_driver_mode(driver_modes)
-
-        self.assertEqual('v2', mode)
-
-    @ddt.data(
-        (), [], '', 'fake1', 'v1', ('v1', ), ['v1'], {}, {'v1': 'v2'}, None,
-        ('fake1', ), ['fake2'], ['fake1', 'fake2'], ('fake2', 'fake1'))
-    def test_get_driver_mode_valid_opt_invalid_cases(self, driver_modes):
-        share_driver = self._instantiate_share_driver(None)
-        share_driver.mode = 'v2'
+    def test_setup_server_handling_enabled(self):
+        share_driver = self._instantiate_share_driver(None, True)
         self.assertRaises(
-            exception.InvalidParameterValue,
-            share_driver.get_driver_mode, driver_modes)
+            NotImplementedError,
+            share_driver.setup_server,
+            'fake_network_info')
 
-    @ddt.data(
-        'v2', ('v2', ), ['v2'], ('v2', 'v1'), ['v2', 'v1'],
-        ('v2', 'fake2'), ['v2', 'fake1'])
-    def test_get_driver_mode_valid_opt_valid_cases(self, driver_modes):
-        share_driver = self._instantiate_share_driver(None)
-        share_driver.mode = 'v2'
+    def test_teardown_server_handling_disabled(self):
+        share_driver = self._instantiate_share_driver(None, False)
+        # We expect successful execution, nothing to assert
+        share_driver.teardown_server('Nothing is expected to happen.')
 
-        mode = share_driver.get_driver_mode(driver_modes)
-
-        self.assertEqual('v2', mode)
+    def test_teardown_server_handling_enabled(self):
+        share_driver = self._instantiate_share_driver(None, True)
+        self.assertRaises(
+            NotImplementedError,
+            share_driver.teardown_server,
+            'fake_share_server_details')
diff --git a/manila/tests/share/test_manager.py b/manila/tests/share/test_manager.py
index f4ae9e6fb5..421296ed0b 100644
--- a/manila/tests/share/test_manager.py
+++ b/manila/tests/share/test_manager.py
@@ -460,7 +460,11 @@ class ShareManagerTestCase(test.TestCase):
             utils.IsAMatcher(models.ShareSnapshot),
             share_server=None)
 
-    def test_create_share_with_share_network_using_single_svm_driver(self):
+    def test_create_share_with_share_network_driver_not_handles_servers(self):
+        manager.CONF.set_default('driver_handles_share_servers', False)
+        self.stubs.Set(
+            self.share_manager.driver.configuration, 'safe_get',
+            mock.Mock(return_value=False))
         share_id = 'fake_share_id'
         share_network_id = 'fake_sn'
         self.stubs.Set(
@@ -468,8 +472,6 @@ class ShareManagerTestCase(test.TestCase):
             mock.Mock(return_value=self._create_share(
                 share_network_id=share_network_id)))
         self.stubs.Set(self.share_manager.db, 'share_update', mock.Mock())
-        self.stubs.Set(
-            self.share_manager.driver, 'mode', constants.SINGLE_SVM_MODE)
 
         self.assertRaises(
             exception.ManilaException,