diff --git a/Gopkg.lock b/Gopkg.lock
index d156510b7aa..f12b3fab1d9 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -266,7 +266,7 @@
     "pkg/metapb",
     "pkg/pdpb"
   ]
-  revision = "7f09068ced84187574699b956cf09530b54884c2"
+  revision = "5e6e69a5ed381bd4a8afe7cb96cc47f955f6d160"
 
 [[projects]]
   name = "github.com/prometheus/client_golang"
@@ -500,6 +500,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "2bf7150e00a5771891754cdf0f5384ded938c1e9cefe9bc8f4822232aac736c9"
+  inputs-digest = "ac20fc02c52f46bfadc23c464c1e9377e5a00e60fd6be6255f58a8e240360b2d"
   solver-name = "gps-cdcl"
   solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
index 870e03a4cb1..a60ac716d7e 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -27,4 +27,3 @@
 [[constraint]]
   name = "github.com/pingcap/kvproto"
   branch = "master"
-
diff --git a/pdctl/command/config_command.go b/pdctl/command/config_command.go
index 37a0852dadf..0104acda3e4 100644
--- a/pdctl/command/config_command.go
+++ b/pdctl/command/config_command.go
@@ -25,11 +25,12 @@ import (
 )
 
 var (
-	configPrefix        = "pd/api/v1/config"
-	schedulePrefix      = "pd/api/v1/config/schedule"
-	replicationPrefix   = "pd/api/v1/config/replicate"
-	namespacePrefix     = "pd/api/v1/config/namespace"
-	labelPropertyPrefix = "pd/api/v1/config/label-property"
+	configPrefix         = "pd/api/v1/config"
+	schedulePrefix       = "pd/api/v1/config/schedule"
+	replicationPrefix    = "pd/api/v1/config/replicate"
+	namespacePrefix      = "pd/api/v1/config/namespace"
+	labelPropertyPrefix  = "pd/api/v1/config/label-property"
+	clusterVersionPrefix = "pd/api/v1/config/cluster-version"
 )
 
 // NewConfigCommand return a config subcommand of rootCmd
@@ -55,6 +56,7 @@ func NewShowConfigCommand() *cobra.Command {
 	sc.AddCommand(NewShowNamespaceConfigCommand())
 	sc.AddCommand(NewShowReplicationConfigCommand())
 	sc.AddCommand(NewShowLabelPropertyCommand())
+	sc.AddCommand(NewShowClusterVersionCommand())
 	return sc
 }
 
@@ -98,15 +100,26 @@ func NewShowLabelPropertyCommand() *cobra.Command {
 	return sc
 }
 
+// NewShowClusterVersionCommand returns a cluster version subcommand of show subcommand.
+func NewShowClusterVersionCommand() *cobra.Command {
+	sc := &cobra.Command{
+		Use:   "cluster-version",
+		Short: "show the cluster version",
+		Run:   showClusterVersionCommandFunc,
+	}
+	return sc
+}
+
 // NewSetConfigCommand return a set subcommand of configCmd
 func NewSetConfigCommand() *cobra.Command {
 	sc := &cobra.Command{
-		Use:   "set <option> <value>, set namespace <name> <option> <value>, set label-property <type> <key> <value>",
+		Use:   "set <option> <value>, set namespace <name> <option> <value>, set label-property <type> <key> <value>, set cluster-version <version>",
 		Short: "set the option with value",
 		Run:   setConfigCommandFunc,
 	}
 	sc.AddCommand(NewSetNamespaceConfigCommand())
 	sc.AddCommand(NewSetLabelPropertyCommand())
+	sc.AddCommand(NewSetClusterVersionCommand())
 	return sc
 }
 
@@ -130,6 +143,16 @@ func NewSetLabelPropertyCommand() *cobra.Command {
 	return sc
 }
 
+// NewSetClusterVersionCommand creates a set subcommand of set subcommand
+func NewSetClusterVersionCommand() *cobra.Command {
+	sc := &cobra.Command{
+		Use:   "cluster-version <version>",
+		Short: "set cluster version",
+		Run:   setClusterVersionCommandFunc,
+	}
+	return sc
+}
+
 // NewDeleteConfigCommand a set subcommand of cfgCmd
 func NewDeleteConfigCommand() *cobra.Command {
 	sc := &cobra.Command{
@@ -211,6 +234,15 @@ func showNamespaceConfigCommandFunc(cmd *cobra.Command, args []string) {
 	fmt.Println(r)
 }
 
+func showClusterVersionCommandFunc(cmd *cobra.Command, args []string) {
+	r, err := doRequest(cmd, clusterVersionPrefix, http.MethodGet)
+	if err != nil {
+		fmt.Printf("Failed to get cluster version: %s\n", err)
+		return
+	}
+	fmt.Println(r)
+}
+
 func postConfigDataWithPath(cmd *cobra.Command, key, value, path string) error {
 	var val interface{}
 	data := make(map[string]interface{})
@@ -305,3 +337,14 @@ func postLabelProperty(cmd *cobra.Command, action string, args []string) {
 	prefix := path.Join(labelPropertyPrefix)
 	postJSON(cmd, prefix, input)
 }
+
+func setClusterVersionCommandFunc(cmd *cobra.Command, args []string) {
+	if len(args) != 1 {
+		fmt.Println(cmd.UsageString())
+		return
+	}
+	input := map[string]interface{}{
+		"cluster-version": args[0],
+	}
+	postJSON(cmd, clusterVersionPrefix, input)
+}
diff --git a/pkg/integration_test/cluster.go b/pkg/integration_test/cluster.go
index a1270d5795c..d1c3ee9a07f 100644
--- a/pkg/integration_test/cluster.go
+++ b/pkg/integration_test/cluster.go
@@ -20,6 +20,7 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/go-semver/semver"
 	"github.com/juju/errors"
 	"github.com/pingcap/kvproto/pkg/pdpb"
 	"github.com/pingcap/pd/server"
@@ -116,6 +117,12 @@ func (s *testServer) GetClusterID() uint64 {
 	return s.server.ClusterID()
 }
 
+func (s *testServer) GetClusterVersion() semver.Version {
+	s.RLock()
+	defer s.RUnlock()
+	return s.server.GetClusterVersion()
+}
+
 func (s *testServer) GetServerID() uint64 {
 	s.RLock()
 	defer s.RUnlock()
diff --git a/pkg/integration_test/version_upgrade_test.go b/pkg/integration_test/version_upgrade_test.go
new file mode 100644
index 00000000000..6846441a1c2
--- /dev/null
+++ b/pkg/integration_test/version_upgrade_test.go
@@ -0,0 +1,148 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration
+
+import (
+	"context"
+
+	"github.com/coreos/go-semver/semver"
+	. "github.com/pingcap/check"
+	"github.com/pingcap/kvproto/pkg/metapb"
+	"github.com/pingcap/kvproto/pkg/pdpb"
+)
+
+func (s *integrationTestSuite) bootstrapCluster(server *testServer, c *C) {
+	bootstrapReq := &pdpb.BootstrapRequest{
+		Header: &pdpb.RequestHeader{ClusterId: server.GetClusterID()},
+		Store:  &metapb.Store{Id: 1, Address: "mock://1"},
+		Region: &metapb.Region{Id: 2, Peers: []*metapb.Peer{{3, 1, false}}},
+	}
+	_, err := server.server.Bootstrap(context.Background(), bootstrapReq)
+	c.Assert(err, IsNil)
+}
+
+func (s *integrationTestSuite) TestStoreRegister(c *C) {
+	c.Parallel()
+	cluster, err := newTestCluster(3)
+	c.Assert(err, IsNil)
+	defer cluster.Destory()
+
+	err = cluster.RunInitialServers()
+	c.Assert(err, IsNil)
+	cluster.WaitLeader()
+	leaderServer := cluster.GetServer(cluster.GetLeader())
+	s.bootstrapCluster(leaderServer, c)
+
+	putStoreRequest := &pdpb.PutStoreRequest{
+		Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+		Store: &metapb.Store{
+			Id:      1,
+			Address: "mock-1",
+			Version: "2.0.1",
+		},
+	}
+	_, err = leaderServer.server.PutStore(context.Background(), putStoreRequest)
+	c.Assert(err, IsNil)
+	// FIX ME: read v0.0.0 in sometime
+	cluster.WaitLeader()
+	version := leaderServer.GetClusterVersion()
+	// Restart all PDs.
+	err = cluster.StopAll()
+	c.Assert(err, IsNil)
+	err = cluster.RunInitialServers()
+	c.Assert(err, IsNil)
+	cluster.WaitLeader()
+
+	leaderServer = cluster.GetServer(cluster.GetLeader())
+	newVersion := leaderServer.GetClusterVersion()
+	c.Assert(version, Equals, newVersion)
+
+	// putNewStore with old version
+	putStoreRequest = &pdpb.PutStoreRequest{
+		Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+		Store: &metapb.Store{
+			Id:      4,
+			Address: "mock-4",
+			Version: "1.0.1",
+		},
+	}
+	_, err = leaderServer.server.PutStore(context.Background(), putStoreRequest)
+	c.Assert(err, NotNil)
+}
+
+func (s *integrationTestSuite) TestRollingUpgrade(c *C) {
+	c.Parallel()
+	cluster, err := newTestCluster(3)
+	c.Assert(err, IsNil)
+	defer cluster.Destory()
+	err = cluster.RunInitialServers()
+	c.Assert(err, IsNil)
+	cluster.WaitLeader()
+	leaderServer := cluster.GetServer(cluster.GetLeader())
+	s.bootstrapCluster(leaderServer, c)
+
+	stores := []*pdpb.PutStoreRequest{
+		{
+			Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+			Store: &metapb.Store{
+				Id:      1,
+				Address: "mock-1",
+				Version: "2.0.1",
+			},
+		},
+		{
+			Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+			Store: &metapb.Store{
+				Id:      4,
+				Address: "mock-4",
+				Version: "2.0.1",
+			},
+		},
+		{
+			Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+			Store: &metapb.Store{
+				Id:      6,
+				Address: "mock-6",
+				Version: "2.0.1",
+			},
+		},
+		{
+			Header: &pdpb.RequestHeader{ClusterId: leaderServer.GetClusterID()},
+			Store: &metapb.Store{
+				Id:      7,
+				Address: "mock-7",
+				Version: "2.0.1",
+			},
+		},
+	}
+	for _, store := range stores {
+		_, err = leaderServer.server.PutStore(context.Background(), store)
+		c.Assert(err, IsNil)
+	}
+	c.Assert(leaderServer.GetClusterVersion(), Equals, semver.Version{Major: 2, Minor: 0, Patch: 1})
+	// rolling update
+	for i, store := range stores {
+		if i == 0 {
+			store.Store.State = metapb.StoreState_Tombstone
+		}
+		store.Store.Version = "2.1.0"
+		resp, err := leaderServer.server.PutStore(context.Background(), store)
+		c.Assert(err, IsNil)
+		if i != len(stores)-1 {
+			c.Assert(leaderServer.GetClusterVersion(), Equals, semver.Version{Major: 2, Minor: 0, Patch: 1})
+			c.Assert(resp.GetHeader().GetError(), IsNil)
+		}
+	}
+	c.Assert(leaderServer.GetClusterVersion(), Equals, semver.Version{Major: 2, Minor: 1})
+}
diff --git a/server/api/config.go b/server/api/config.go
index f81a7920d0c..6e93974984a 100644
--- a/server/api/config.go
+++ b/server/api/config.go
@@ -21,6 +21,7 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/juju/errors"
+	"github.com/pingcap/pd/pkg/error_code"
 	"github.com/pingcap/pd/server"
 	"github.com/unrolled/render"
 )
@@ -168,3 +169,25 @@ func (h *confHandler) SetLabelProperty(w http.ResponseWriter, r *http.Request) {
 	}
 	h.rd.JSON(w, http.StatusOK, nil)
 }
+
+func (h *confHandler) GetClusterVersion(w http.ResponseWriter, r *http.Request) {
+	h.rd.JSON(w, http.StatusOK, h.svr.GetClusterVersion())
+}
+
+func (h *confHandler) SetClusterVersion(w http.ResponseWriter, r *http.Request) {
+	input := make(map[string]string)
+	if err := readJSONRespondError(h.rd, w, r.Body, &input); err != nil {
+		return
+	}
+	version, ok := input["cluster-version"]
+	if !ok {
+		errorResp(h.rd, w, errcode.NewInvalidInputErr(errors.New("not set cluster-version")))
+		return
+	}
+	err := h.svr.SetClusterVersion(version)
+	if err != nil {
+		errorResp(h.rd, w, errcode.NewInternalErr(err))
+		return
+	}
+	h.rd.JSON(w, http.StatusOK, nil)
+}
diff --git a/server/api/label_test.go b/server/api/label_test.go
index 62fba9622a8..105d5ecc89b 100644
--- a/server/api/label_test.go
+++ b/server/api/label_test.go
@@ -46,6 +46,7 @@ func (s *testLabelsStoreSuite) SetUpSuite(c *C) {
 					Value: "ssd",
 				},
 			},
+			Version: "2.0.0",
 		},
 		{
 			Id:      4,
@@ -61,6 +62,7 @@ func (s *testLabelsStoreSuite) SetUpSuite(c *C) {
 					Value: "hdd",
 				},
 			},
+			Version: "2.0.0",
 		},
 		{
 			Id:      6,
@@ -76,6 +78,7 @@ func (s *testLabelsStoreSuite) SetUpSuite(c *C) {
 					Value: "ssd",
 				},
 			},
+			Version: "2.0.0",
 		},
 		{
 			Id:      7,
@@ -95,6 +98,7 @@ func (s *testLabelsStoreSuite) SetUpSuite(c *C) {
 					Value: "test",
 				},
 			},
+			Version: "2.0.0",
 		},
 	}
 
diff --git a/server/api/operator_test.go b/server/api/operator_test.go
index 966c9dcbd23..c354270989a 100644
--- a/server/api/operator_test.go
+++ b/server/api/operator_test.go
@@ -87,6 +87,7 @@ func mustPutStore(c *C, svr *server.Server, id uint64, state metapb.StoreState,
 			Address: fmt.Sprintf("tikv%d", id),
 			State:   state,
 			Labels:  labels,
+			Version: server.MinSupportedVersion(server.Version2_0).String(),
 		},
 	})
 	c.Assert(err, IsNil)
diff --git a/server/api/router.go b/server/api/router.go
index c2fc36e8eb3..b3e2c573516 100644
--- a/server/api/router.go
+++ b/server/api/router.go
@@ -58,6 +58,8 @@ func createRouter(prefix string, svr *server.Server) *mux.Router {
 	router.HandleFunc("/api/v1/config/namespace/{name}", confHandler.DeleteNamespace).Methods("DELETE")
 	router.HandleFunc("/api/v1/config/label-property", confHandler.GetLabelProperty).Methods("GET")
 	router.HandleFunc("/api/v1/config/label-property", confHandler.SetLabelProperty).Methods("POST")
+	router.HandleFunc("/api/v1/config/cluster-version", confHandler.GetClusterVersion).Methods("GET")
+	router.HandleFunc("/api/v1/config/cluster-version", confHandler.SetClusterVersion).Methods("POST")
 
 	storeHandler := newStoreHandler(svr, rd)
 	router.HandleFunc("/api/v1/store/{id}", storeHandler.Get).Methods("GET")
diff --git a/server/api/store_test.go b/server/api/store_test.go
index 06b2d21b1f1..977141a2eac 100644
--- a/server/api/store_test.go
+++ b/server/api/store_test.go
@@ -55,23 +55,27 @@ func (s *testStoreSuite) SetUpSuite(c *C) {
 			Id:      1,
 			Address: "tikv1",
 			State:   metapb.StoreState_Up,
+			Version: "2.0.0",
 		},
 		{
 			Id:      4,
 			Address: "tikv4",
 			State:   metapb.StoreState_Up,
+			Version: "2.0.0",
 		},
 		{
 			// metapb.StoreState_Offline == 1
 			Id:      6,
 			Address: "tikv6",
 			State:   metapb.StoreState_Offline,
+			Version: "2.0.0",
 		},
 		{
 			// metapb.StoreState_Tombstone == 2
 			Id:      7,
 			Address: "tikv7",
 			State:   metapb.StoreState_Tombstone,
+			Version: "2.0.0",
 		},
 	}
 
diff --git a/server/cluster.go b/server/cluster.go
index 9e2cf2ab5a9..34846b3bdeb 100644
--- a/server/cluster.go
+++ b/server/cluster.go
@@ -290,6 +290,15 @@ func (c *RaftCluster) putStore(store *metapb.Store) error {
 		return errors.Errorf("invalid put store %v", store)
 	}
 
+	v, err := ParseVersion(store.GetVersion())
+	if err != nil {
+		return errors.Errorf("invalid put store %v, error: %s", store, err)
+	}
+	clusterVersion := c.cachedCluster.opt.loadClusterVersion()
+	if !IsCompatible(clusterVersion, *v) {
+		return errors.Errorf("version should compatible with version  %s, got %s", clusterVersion, v)
+	}
+
 	cluster := c.cachedCluster
 
 	// Store address can not be the same as other stores.
@@ -310,16 +319,15 @@ func (c *RaftCluster) putStore(store *metapb.Store) error {
 	} else {
 		// Update an existed store.
 		s.Address = store.Address
+		s.Version = store.Version
 		s.MergeLabels(store.Labels)
 	}
-
 	// Check location labels.
 	for _, k := range c.cachedCluster.GetLocationLabels() {
 		if v := s.GetLabelValue(k); len(v) == 0 {
 			log.Warnf("missing location label %q in store %v", k, s)
 		}
 	}
-
 	return cluster.putStore(s)
 }
 
diff --git a/server/cluster_info.go b/server/cluster_info.go
index a4416c20e05..0368f2f9b24 100644
--- a/server/cluster_info.go
+++ b/server/cluster_info.go
@@ -17,6 +17,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/coreos/go-semver/semver"
 	"github.com/gogo/protobuf/proto"
 	"github.com/juju/errors"
 	"github.com/pingcap/kvproto/pkg/metapb"
@@ -78,6 +79,42 @@ func loadClusterInfo(id core.IDAllocator, kv *core.KV, opt *scheduleOption) (*cl
 	return c, nil
 }
 
+func (c *clusterInfo) OnStoreVersionChange() {
+	var (
+		minVersion     *semver.Version
+		clusterVersion semver.Version
+	)
+
+	clusterVersion = c.opt.loadClusterVersion()
+	stores := c.GetStores()
+	for _, s := range stores {
+		if s.IsTombstone() {
+			continue
+		}
+		v := MustParseVersion(s.GetVersion())
+
+		if minVersion == nil || v.LessThan(*minVersion) {
+			minVersion = v
+		}
+	}
+	if clusterVersion.LessThan(*minVersion) {
+		c.opt.SetClusterVersion(*minVersion)
+		err := c.opt.persist(c.kv)
+		if err != nil {
+			log.Infof("persist cluster version meet error: %s", err)
+		}
+		log.Infof("cluster version changed from %s to %s", clusterVersion, minVersion)
+		CheckPDVersion(c.opt)
+	}
+}
+
+// IsFeatureSupported checks if the feature is supported by current cluster.
+func (c *clusterInfo) IsFeatureSupported(f Feature) bool {
+	clusterVersion := c.opt.loadClusterVersion()
+	minSupportVersion := MinSupportedVersion(f)
+	return !clusterVersion.LessThan(minSupportVersion)
+}
+
 func (c *clusterInfo) allocID() (uint64, error) {
 	return c.id.Alloc()
 }
@@ -618,6 +655,9 @@ func (c *clusterInfo) GetHotRegionLowThreshold() int {
 }
 
 func (c *clusterInfo) IsRaftLearnerEnabled() bool {
+	if !c.IsFeatureSupported(RaftLearner) {
+		return false
+	}
 	return c.opt.IsRaftLearnerEnabled()
 }
 
diff --git a/server/config.go b/server/config.go
index e13d1e22842..8ccf2ff4f10 100644
--- a/server/config.go
+++ b/server/config.go
@@ -26,6 +26,7 @@ import (
 	"github.com/BurntSushi/toml"
 	"github.com/coreos/etcd/embed"
 	"github.com/coreos/etcd/pkg/transport"
+	"github.com/coreos/go-semver/semver"
 	"github.com/juju/errors"
 	"github.com/pingcap/pd/pkg/logutil"
 	"github.com/pingcap/pd/pkg/metricutil"
@@ -77,6 +78,8 @@ type Config struct {
 
 	Namespace map[string]NamespaceConfig `json:"namespace"`
 
+	ClusterVersion semver.Version `json:"cluster-version"`
+
 	// QuotaBackendBytes Raise alarms when backend size exceeds the given quota. 0 means use the default quota.
 	// the default size is 2GB, the maximum is 8GB.
 	QuotaBackendBytes typeutil.ByteSize `toml:"quota-backend-bytes" json:"quota-backend-bytes"`
diff --git a/server/coordinator.go b/server/coordinator.go
index d83b6221446..8dda461e7ac 100644
--- a/server/coordinator.go
+++ b/server/coordinator.go
@@ -185,7 +185,7 @@ func (c *coordinator) checkRegion(region *core.RegionInfo) bool {
 			}
 		}
 	}
-	if c.limiter.OperatorCount(schedule.OpMerge) < c.cluster.GetMergeScheduleLimit() {
+	if c.cluster.IsFeatureSupported(RegionMerge) && c.limiter.OperatorCount(schedule.OpMerge) < c.cluster.GetMergeScheduleLimit() {
 		if op1, op2 := c.mergeChecker.Check(region); op1 != nil && op2 != nil {
 			// make sure two operators can add successfully altogether
 			if c.addOperator(op1, op2) {
diff --git a/server/coordinator_test.go b/server/coordinator_test.go
index a7eabbcadc0..315f36633c9 100644
--- a/server/coordinator_test.go
+++ b/server/coordinator_test.go
@@ -38,6 +38,7 @@ func newTestScheduleConfig() (*ScheduleConfig, *scheduleOption) {
 	cfg := NewConfig()
 	cfg.adjust(nil)
 	opt := newScheduleOption(cfg)
+	opt.SetClusterVersion(MinSupportedVersion(Version2_0))
 	return &cfg.Schedule, opt
 }
 
diff --git a/server/grpc_service.go b/server/grpc_service.go
index 32902ca6404..66779f1ee52 100644
--- a/server/grpc_service.go
+++ b/server/grpc_service.go
@@ -218,6 +218,7 @@ func (s *Server) PutStore(ctx context.Context, request *pdpb.PutStoreRequest) (*
 	}
 
 	log.Infof("put store ok - %v", store)
+	cluster.cachedCluster.OnStoreVersionChange()
 
 	return &pdpb.PutStoreResponse{
 		Header: s.header(),
diff --git a/server/leader.go b/server/leader.go
index 8329ea399b7..472be46c01f 100644
--- a/server/leader.go
+++ b/server/leader.go
@@ -265,7 +265,9 @@ func (s *Server) campaignLeader() error {
 	s.enableLeader(true)
 	defer s.enableLeader(false)
 
+	log.Infof("cluster version is %s", s.scheduleOpt.loadClusterVersion())
 	log.Infof("PD cluster leader %s is ready to serve", s.Name())
+	CheckPDVersion(s.scheduleOpt)
 
 	tsTicker := time.NewTicker(updateTimestampStep)
 	defer tsTicker.Stop()
diff --git a/server/option.go b/server/option.go
index 0d710ca0fb8..d476f63f24d 100644
--- a/server/option.go
+++ b/server/option.go
@@ -18,6 +18,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/coreos/go-semver/semver"
 	"github.com/juju/errors"
 	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/pd/server/core"
@@ -26,10 +27,11 @@ import (
 
 // scheduleOption is a wrapper to access the configuration safely.
 type scheduleOption struct {
-	v             atomic.Value
-	rep           *Replication
-	ns            map[string]*namespaceOption
-	labelProperty atomic.Value
+	v              atomic.Value
+	rep            *Replication
+	ns             map[string]*namespaceOption
+	labelProperty  atomic.Value
+	clusterVersion atomic.Value
 }
 
 func newScheduleOption(cfg *Config) *scheduleOption {
@@ -42,6 +44,7 @@ func newScheduleOption(cfg *Config) *scheduleOption {
 	}
 	o.rep = newReplication(&cfg.Replication)
 	o.labelProperty.Store(cfg.LabelProperty)
+	o.clusterVersion.Store(cfg.ClusterVersion)
 	return o
 }
 
@@ -245,16 +248,25 @@ func (o *scheduleOption) loadLabelPropertyConfig() LabelPropertyConfig {
 	return o.labelProperty.Load().(LabelPropertyConfig)
 }
 
+func (o *scheduleOption) SetClusterVersion(v semver.Version) {
+	o.clusterVersion.Store(v)
+}
+
+func (o *scheduleOption) loadClusterVersion() semver.Version {
+	return o.clusterVersion.Load().(semver.Version)
+}
+
 func (o *scheduleOption) persist(kv *core.KV) error {
 	namespaces := make(map[string]NamespaceConfig)
 	for name, ns := range o.ns {
 		namespaces[name] = *ns.load()
 	}
 	cfg := &Config{
-		Schedule:      *o.load(),
-		Replication:   *o.rep.load(),
-		Namespace:     namespaces,
-		LabelProperty: o.loadLabelPropertyConfig(),
+		Schedule:       *o.load(),
+		Replication:    *o.rep.load(),
+		Namespace:      namespaces,
+		LabelProperty:  o.loadLabelPropertyConfig(),
+		ClusterVersion: o.loadClusterVersion(),
 	}
 	err := kv.SaveConfig(cfg)
 	return errors.Trace(err)
@@ -266,10 +278,11 @@ func (o *scheduleOption) reload(kv *core.KV) error {
 		namespaces[name] = *ns.load()
 	}
 	cfg := &Config{
-		Schedule:      *o.load().clone(),
-		Replication:   *o.rep.load(),
-		Namespace:     namespaces,
-		LabelProperty: o.loadLabelPropertyConfig().clone(),
+		Schedule:       *o.load().clone(),
+		Replication:    *o.rep.load(),
+		Namespace:      namespaces,
+		LabelProperty:  o.loadLabelPropertyConfig().clone(),
+		ClusterVersion: o.loadClusterVersion(),
 	}
 	isExist, err := kv.LoadConfig(cfg)
 	if err != nil {
@@ -284,6 +297,7 @@ func (o *scheduleOption) reload(kv *core.KV) error {
 			o.ns[name] = newNamespaceOption(&nsCfg)
 		}
 		o.labelProperty.Store(cfg.LabelProperty)
+		o.clusterVersion.Store(cfg.ClusterVersion)
 	}
 	return nil
 }
diff --git a/server/server.go b/server/server.go
index b5d75e6b625..dc439cc118c 100644
--- a/server/server.go
+++ b/server/server.go
@@ -28,6 +28,7 @@ import (
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/embed"
 	"github.com/coreos/etcd/pkg/types"
+	"github.com/coreos/go-semver/semver"
 	"github.com/juju/errors"
 	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/kvproto/pkg/pdpb"
@@ -423,6 +424,7 @@ func (s *Server) GetConfig() *Config {
 	}
 	cfg.Namespace = namespaces
 	cfg.LabelProperty = s.scheduleOpt.loadLabelPropertyConfig().clone()
+	cfg.ClusterVersion = s.scheduleOpt.loadClusterVersion()
 	return cfg
 }
 
@@ -543,6 +545,26 @@ func (s *Server) GetLabelProperty() LabelPropertyConfig {
 	return s.scheduleOpt.loadLabelPropertyConfig().clone()
 }
 
+// SetClusterVersion sets the version of cluster.
+func (s *Server) SetClusterVersion(v string) error {
+	version, err := ParseVersion(v)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	s.scheduleOpt.SetClusterVersion(*version)
+	err = s.scheduleOpt.persist(s.kv)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	log.Infof("cluster version is updated to %s", v)
+	return nil
+}
+
+// GetClusterVersion returns the version of cluster.
+func (s *Server) GetClusterVersion() semver.Version {
+	return s.scheduleOpt.loadClusterVersion()
+}
+
 // GetSecurityConfig get the security config.
 func (s *Server) GetSecurityConfig() *SecurityConfig {
 	return &s.cfg.Security
diff --git a/server/util.go b/server/util.go
index b9d2587392f..5c49c28c0fb 100644
--- a/server/util.go
+++ b/server/util.go
@@ -68,6 +68,18 @@ func PrintPDInfo() {
 	fmt.Println("UTC Build Time: ", PDBuildTS)
 }
 
+// CheckPDVersion checks if PD needs to be upgraded.
+func CheckPDVersion(opt *scheduleOption) {
+	pdVersion := MinSupportedVersion(Base)
+	if PDReleaseVersion != "None" {
+		pdVersion = *MustParseVersion(PDReleaseVersion)
+	}
+	clusterVersion := opt.loadClusterVersion()
+	if pdVersion.LessThan(clusterVersion) {
+		log.Warnf("PD version %s less than cluster version: %s, please upgrade PD", pdVersion, clusterVersion)
+	}
+}
+
 // A helper function to get value with key from etcd.
 // TODO: return the value revision for outer use.
 func getValue(c *clientv3.Client, key string, opts ...clientv3.OpOption) ([]byte, error) {
diff --git a/server/version.go b/server/version.go
new file mode 100644
index 00000000000..9f3acf925c6
--- /dev/null
+++ b/server/version.go
@@ -0,0 +1,88 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"github.com/coreos/go-semver/semver"
+	log "github.com/sirupsen/logrus"
+)
+
+// Feature supported features.
+type Feature int
+
+// Fetures list.
+// The cluster provides corresponding new features if the cluster version
+// greater than or equal to the required minimum version of the feature.
+const (
+	Base Feature = iota
+	Version2_0
+	// RegionMerge supports the adjacent regions to be merged.
+	// and PD will periodically check if there is enough small
+	// region to be merged. if there is, will send the corresponding
+	// merge command to the TiKV.
+	RegionMerge
+	// RaftLearner supports add a non-voting member in raft members.
+	// and PD scheduling strategy will replace `addPeer` to `addLearner`,`promotoLearner`.
+	RaftLearner
+	// BatchSplit can speed up the region split.
+	// and PD will response the BatchSplit request.
+	BatchSplit
+)
+
+var featuresDict = map[Feature]string{
+	Base:        "1.0.0",
+	Version2_0:  "2.0.0",
+	RegionMerge: "2.0.0",
+	RaftLearner: "2.0.0",
+	BatchSplit:  "2.1.0",
+}
+
+// MinSupportedVersion returns the minimum support version for the specified feature.
+func MinSupportedVersion(v Feature) semver.Version {
+	target, ok := featuresDict[v]
+	if !ok {
+		log.Fatalf("the corresponding version of the feature %d doesn't exist", v)
+	}
+	version := MustParseVersion(target)
+	return *version
+}
+
+// ParseVersion wraps semver.NewVersion and handles compatibility issues.
+func ParseVersion(v string) (*semver.Version, error) {
+	// for compatibility with old version which not support `version` mechanism.
+	if v == "" {
+		return semver.New(featuresDict[Base]), nil
+	}
+	if v[0] == 'v' {
+		v = v[1:]
+	}
+	return semver.NewVersion(v)
+}
+
+// MustParseVersion wraps ParseVersion and will panic if error is not nil.
+func MustParseVersion(v string) *semver.Version {
+	ver, err := ParseVersion(v)
+	if err != nil {
+		log.Fatalf("version string is illegal: %s", err)
+	}
+	return ver
+}
+
+// IsCompatible checks if the clusterVersion is compatible with the specified version.
+func IsCompatible(clusterVersion, v semver.Version) bool {
+	if clusterVersion.LessThan(v) {
+		return true
+	}
+	return clusterVersion.Major == v.Major && clusterVersion.Minor == v.Minor
+}
diff --git a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
index 5d350673510..3dd14dc328b 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: eraftpb.proto
-// DO NOT EDIT!
 
 /*
 	Package eraftpb is a generated protocol buffer package.
@@ -1903,7 +1902,24 @@ func (m *ConfState) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
-			if wireType == 2 {
+			if wireType == 0 {
+				var v uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowEraftpb
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.Nodes = append(m.Nodes, v)
+			} else if wireType == 2 {
 				var packedLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
@@ -1944,7 +1960,11 @@ func (m *ConfState) Unmarshal(dAtA []byte) error {
 					}
 					m.Nodes = append(m.Nodes, v)
 				}
-			} else if wireType == 0 {
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
+			}
+		case 2:
+			if wireType == 0 {
 				var v uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
@@ -1960,12 +1980,8 @@ func (m *ConfState) Unmarshal(dAtA []byte) error {
 						break
 					}
 				}
-				m.Nodes = append(m.Nodes, v)
-			} else {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
-			}
-		case 2:
-			if wireType == 2 {
+				m.Learners = append(m.Learners, v)
+			} else if wireType == 2 {
 				var packedLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
@@ -2006,23 +2022,6 @@ func (m *ConfState) Unmarshal(dAtA []byte) error {
 					}
 					m.Learners = append(m.Learners, v)
 				}
-			} else if wireType == 0 {
-				var v uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowEraftpb
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				m.Learners = append(m.Learners, v)
 			} else {
 				return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType)
 			}
diff --git a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
index 497f52d332b..9283c6a74c1 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: metapb.proto
-// DO NOT EDIT!
 
 /*
 	Package metapb is a generated protocol buffer package.
@@ -117,6 +116,7 @@ type Store struct {
 	Address string        `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
 	State   StoreState    `protobuf:"varint,3,opt,name=state,proto3,enum=metapb.StoreState" json:"state,omitempty"`
 	Labels  []*StoreLabel `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"`
+	Version string        `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
 }
 
 func (m *Store) Reset()                    { *m = Store{} }
@@ -152,6 +152,13 @@ func (m *Store) GetLabels() []*StoreLabel {
 	return nil
 }
 
+func (m *Store) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
 type RegionEpoch struct {
 	// Conf change version, auto increment when add or remove peer
 	ConfVer uint64 `protobuf:"varint,1,opt,name=conf_ver,json=confVer,proto3" json:"conf_ver,omitempty"`
@@ -369,6 +376,12 @@ func (m *Store) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if len(m.Version) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintMetapb(dAtA, i, uint64(len(m.Version)))
+		i += copy(dAtA[i:], m.Version)
+	}
 	return i, nil
 }
 
@@ -567,6 +580,10 @@ func (m *Store) Size() (n int) {
 			n += 1 + l + sovMetapb(uint64(l))
 		}
 	}
+	l = len(m.Version)
+	if l > 0 {
+		n += 1 + l + sovMetapb(uint64(l))
+	}
 	return n
 }
 
@@ -960,6 +977,35 @@ func (m *Store) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMetapb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthMetapb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Version = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMetapb(dAtA[iNdEx:])
@@ -1480,35 +1526,35 @@ var (
 func init() { proto.RegisterFile("metapb.proto", fileDescriptorMetapb) }
 
 var fileDescriptorMetapb = []byte{
-	// 474 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x92, 0xcf, 0x8e, 0xd3, 0x30,
-	0x10, 0xc6, 0xd7, 0xfd, 0x93, 0xb6, 0xd3, 0x6e, 0x55, 0x99, 0x95, 0xc8, 0x82, 0xa8, 0xaa, 0x88,
-	0x43, 0xd4, 0x43, 0x41, 0x0b, 0xe2, 0x8a, 0xb4, 0x2b, 0x0e, 0x88, 0x95, 0x58, 0x79, 0x81, 0x6b,
-	0xe4, 0x26, 0xd3, 0x62, 0x35, 0xb1, 0x23, 0xdb, 0x8d, 0x76, 0x9f, 0x80, 0x57, 0xe0, 0x19, 0x78,
-	0x12, 0x8e, 0x3c, 0x02, 0x2a, 0x2f, 0x82, 0xec, 0x24, 0xd2, 0x6a, 0x7b, 0x8a, 0xbf, 0xf9, 0x66,
-	0x26, 0xbf, 0xf1, 0x18, 0x26, 0x05, 0x5a, 0x5e, 0xae, 0x57, 0xa5, 0x56, 0x56, 0xd1, 0xa0, 0x56,
-	0xcf, 0xce, 0xb6, 0x6a, 0xab, 0x7c, 0xe8, 0x95, 0x3b, 0xd5, 0x6e, 0xf4, 0x1e, 0x06, 0x57, 0xf9,
-	0xde, 0x58, 0xd4, 0x74, 0x0a, 0x1d, 0x91, 0x85, 0x64, 0x41, 0xe2, 0x1e, 0xeb, 0x88, 0x8c, 0xbe,
-	0x84, 0x69, 0xc1, 0xef, 0x92, 0x12, 0x51, 0x27, 0xa9, 0xda, 0x4b, 0x1b, 0x76, 0x16, 0x24, 0x3e,
-	0x65, 0x93, 0x82, 0xdf, 0xdd, 0x20, 0xea, 0x2b, 0x17, 0x8b, 0xde, 0x02, 0xdc, 0x5a, 0xa5, 0xf1,
-	0x9a, 0xaf, 0x31, 0xa7, 0x33, 0xe8, 0xee, 0xf0, 0xde, 0x37, 0x19, 0x31, 0x77, 0xa4, 0x67, 0xd0,
-	0xaf, 0x78, 0xbe, 0x47, 0x5f, 0x3c, 0x62, 0xb5, 0x88, 0x7e, 0x10, 0xe8, 0xfb, 0xb2, 0xa3, 0xbf,
-	0x86, 0x30, 0xe0, 0x59, 0xa6, 0xd1, 0x98, 0xa6, 0xa2, 0x95, 0x34, 0x86, 0xbe, 0xb1, 0xdc, 0x62,
-	0xd8, 0x5d, 0x90, 0x78, 0x7a, 0x41, 0x57, 0xcd, 0x98, 0xbe, 0xcf, 0xad, 0x73, 0x58, 0x9d, 0x40,
-	0x97, 0x10, 0xe4, 0x0e, 0xc7, 0x84, 0xbd, 0x45, 0x37, 0x1e, 0x3f, 0x4a, 0xf5, 0xa4, 0xac, 0xc9,
-	0x88, 0x2e, 0x61, 0xcc, 0x70, 0x2b, 0x94, 0xfc, 0x50, 0xaa, 0xf4, 0x3b, 0x3d, 0x87, 0x61, 0xaa,
-	0xe4, 0x26, 0xa9, 0x50, 0x37, 0x50, 0x03, 0xa7, 0xbf, 0xa1, 0x76, 0x64, 0x15, 0x6a, 0x23, 0x94,
-	0xf4, 0x64, 0x3d, 0xd6, 0xca, 0xe8, 0x17, 0x81, 0xa0, 0x6e, 0x72, 0x34, 0xce, 0x73, 0x18, 0x19,
-	0xcb, 0xb5, 0x4d, 0xdc, 0xb5, 0xb8, 0xb2, 0x09, 0x1b, 0xfa, 0xc0, 0x27, 0xbc, 0xa7, 0x4f, 0x61,
-	0x80, 0x32, 0xf3, 0x56, 0xd7, 0x5b, 0x01, 0xca, 0xcc, 0x19, 0xef, 0x60, 0xa2, 0x7d, 0xbf, 0x04,
-	0x1d, 0x55, 0xd8, 0x5b, 0x90, 0x78, 0x7c, 0xf1, 0xa4, 0x1d, 0xe3, 0x01, 0x30, 0x1b, 0xeb, 0x07,
-	0xf4, 0x11, 0xf4, 0xdd, 0xba, 0x4c, 0xd8, 0xf7, 0x73, 0x4f, 0xda, 0x02, 0xb7, 0x2e, 0x56, 0x5b,
-	0xd1, 0x0d, 0xf4, 0x9c, 0x3c, 0x22, 0x3d, 0x87, 0xa1, 0x71, 0xd7, 0x93, 0x88, 0xac, 0x9d, 0xcf,
-	0xeb, 0x8f, 0x19, 0x7d, 0x01, 0x20, 0x4c, 0x92, 0x23, 0xd7, 0x12, 0xb5, 0x47, 0x1d, 0xb2, 0x91,
-	0x30, 0xd7, 0x75, 0x60, 0xf9, 0xba, 0x79, 0x02, 0x7e, 0x07, 0x34, 0x80, 0xce, 0xd7, 0x72, 0x76,
-	0x42, 0xc7, 0x30, 0xf8, 0xbc, 0xd9, 0xe4, 0x42, 0xe2, 0x8c, 0xd0, 0x53, 0x18, 0x7d, 0x51, 0xc5,
-	0xda, 0x58, 0x25, 0x71, 0xd6, 0xb9, 0x5c, 0xfe, 0x3e, 0xcc, 0xc9, 0x9f, 0xc3, 0x9c, 0xfc, 0x3d,
-	0xcc, 0xc9, 0xcf, 0x7f, 0xf3, 0x13, 0x08, 0x53, 0x55, 0xac, 0x4a, 0x21, 0xb7, 0x29, 0x2f, 0x57,
-	0x56, 0xec, 0xaa, 0xd5, 0xae, 0xf2, 0x2f, 0x74, 0x1d, 0xf8, 0xcf, 0x9b, 0xff, 0x01, 0x00, 0x00,
-	0xff, 0xff, 0x2a, 0x28, 0xbc, 0x30, 0xd6, 0x02, 0x00, 0x00,
+	// 479 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0xc1, 0x8e, 0xd3, 0x3c,
+	0x10, 0x5e, 0xa7, 0x4d, 0xda, 0x4e, 0xbb, 0x55, 0xe5, 0x7f, 0xa5, 0x3f, 0x0b, 0xa2, 0xaa, 0x22,
+	0x0e, 0x51, 0x0f, 0x05, 0x2d, 0x88, 0x2b, 0xd2, 0xae, 0x38, 0x20, 0x56, 0x62, 0xe5, 0x05, 0xae,
+	0x91, 0xdb, 0x4c, 0x8b, 0xd5, 0xd4, 0x8e, 0x6c, 0x37, 0xda, 0x7d, 0x13, 0xae, 0x5c, 0x79, 0x12,
+	0x8e, 0x3c, 0x02, 0x2a, 0x2f, 0x82, 0xec, 0x24, 0x52, 0x45, 0x4f, 0xc9, 0x37, 0xdf, 0xcc, 0x37,
+	0xdf, 0xcc, 0x18, 0x46, 0x3b, 0xb4, 0xbc, 0x5c, 0x2e, 0x4a, 0xad, 0xac, 0xa2, 0x51, 0x8d, 0x9e,
+	0x5c, 0x6c, 0xd4, 0x46, 0xf9, 0xd0, 0x0b, 0xf7, 0x57, 0xb3, 0xc9, 0x5b, 0xe8, 0xdd, 0x14, 0x7b,
+	0x63, 0x51, 0xd3, 0x31, 0x04, 0x22, 0x8f, 0xc9, 0x8c, 0xa4, 0x5d, 0x16, 0x88, 0x9c, 0x3e, 0x87,
+	0xf1, 0x8e, 0x3f, 0x64, 0x25, 0xa2, 0xce, 0x56, 0x6a, 0x2f, 0x6d, 0x1c, 0xcc, 0x48, 0x7a, 0xce,
+	0x46, 0x3b, 0xfe, 0x70, 0x87, 0xa8, 0x6f, 0x5c, 0x2c, 0x79, 0x0d, 0x70, 0x6f, 0x95, 0xc6, 0x5b,
+	0xbe, 0xc4, 0x82, 0x4e, 0xa0, 0xb3, 0xc5, 0x47, 0x2f, 0x32, 0x60, 0xee, 0x97, 0x5e, 0x40, 0x58,
+	0xf1, 0x62, 0x8f, 0xbe, 0x78, 0xc0, 0x6a, 0x90, 0x7c, 0x27, 0x10, 0xfa, 0xb2, 0x93, 0xae, 0x31,
+	0xf4, 0x78, 0x9e, 0x6b, 0x34, 0xa6, 0xa9, 0x68, 0x21, 0x4d, 0x21, 0x34, 0x96, 0x5b, 0x8c, 0x3b,
+	0x33, 0x92, 0x8e, 0xaf, 0xe8, 0xa2, 0x19, 0xd3, 0xeb, 0xdc, 0x3b, 0x86, 0xd5, 0x09, 0x74, 0x0e,
+	0x51, 0xe1, 0xec, 0x98, 0xb8, 0x3b, 0xeb, 0xa4, 0xc3, 0x7f, 0x52, 0xbd, 0x53, 0xd6, 0x64, 0xb8,
+	0x7e, 0x15, 0x6a, 0x23, 0x94, 0x8c, 0xc3, 0xba, 0x5f, 0x03, 0x93, 0x6b, 0x18, 0x32, 0xdc, 0x08,
+	0x25, 0xdf, 0x95, 0x6a, 0xf5, 0x95, 0x5e, 0x42, 0x7f, 0xa5, 0xe4, 0x3a, 0xab, 0x50, 0x37, 0x76,
+	0x7b, 0x0e, 0x7f, 0x41, 0x7d, 0xac, 0x11, 0xd4, 0x4c, 0xab, 0xf1, 0x83, 0x40, 0x54, 0x8b, 0x9c,
+	0x0c, 0xfa, 0x14, 0x06, 0xc6, 0x72, 0x6d, 0x33, 0xb7, 0x30, 0x57, 0x36, 0x62, 0x7d, 0x1f, 0xf8,
+	0x80, 0x8f, 0xf4, 0x7f, 0xe8, 0xa1, 0xcc, 0x3d, 0xd5, 0xf1, 0x54, 0x84, 0x32, 0x77, 0xc4, 0x1b,
+	0x18, 0x69, 0xaf, 0x97, 0xa1, 0x73, 0x15, 0x77, 0x67, 0x24, 0x1d, 0x5e, 0xfd, 0xd7, 0x0e, 0x78,
+	0x64, 0x98, 0x0d, 0xf5, 0x91, 0xfb, 0x04, 0x42, 0x77, 0x48, 0x13, 0x87, 0x7e, 0x23, 0xa3, 0xb6,
+	0xc0, 0x1d, 0x92, 0xd5, 0x54, 0x72, 0x07, 0x5d, 0x07, 0x4f, 0x9c, 0x5e, 0x42, 0xdf, 0xb8, 0xc5,
+	0x65, 0x22, 0x6f, 0xe7, 0xf3, 0xf8, 0x7d, 0x4e, 0x9f, 0x01, 0x08, 0x93, 0x15, 0xc8, 0xb5, 0x44,
+	0xed, 0xad, 0xf6, 0xd9, 0x40, 0x98, 0xdb, 0x3a, 0x30, 0x7f, 0xd9, 0x3c, 0x0e, 0x7f, 0x1d, 0x1a,
+	0x41, 0xf0, 0xb9, 0x9c, 0x9c, 0xd1, 0x21, 0xf4, 0x3e, 0xae, 0xd7, 0x85, 0x90, 0x38, 0x21, 0xf4,
+	0x1c, 0x06, 0x9f, 0xd4, 0x6e, 0x69, 0xac, 0x92, 0x38, 0x09, 0xae, 0xe7, 0x3f, 0x0f, 0x53, 0xf2,
+	0xeb, 0x30, 0x25, 0xbf, 0x0f, 0x53, 0xf2, 0xed, 0xcf, 0xf4, 0x0c, 0xe2, 0x95, 0xda, 0x2d, 0x4a,
+	0x21, 0x37, 0x2b, 0x5e, 0x2e, 0xac, 0xd8, 0x56, 0x8b, 0x6d, 0xe5, 0xdf, 0xee, 0x32, 0xf2, 0x9f,
+	0x57, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x59, 0x52, 0x48, 0xf0, 0x02, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
index 163005912d6..9a9fb532898 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: pdpb.proto
-// DO NOT EDIT!
 
 /*
 	Package pdpb is a generated protocol buffer package.
@@ -9376,7 +9375,24 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error {
 				}
 			}
 		case 3:
-			if wireType == 2 {
+			if wireType == 0 {
+				var v uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowPdpb
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.NewPeerIds = append(m.NewPeerIds, v)
+			} else if wireType == 2 {
 				var packedLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
@@ -9417,23 +9433,6 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error {
 					}
 					m.NewPeerIds = append(m.NewPeerIds, v)
 				}
-			} else if wireType == 0 {
-				var v uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowPdpb
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				m.NewPeerIds = append(m.NewPeerIds, v)
 			} else {
 				return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType)
 			}