o/configstate, o/snapstate: make disk-space checks respect system.disk-space-reservation option

Author: andrewphelpsj

overlord/configstate/configcore/diskspace.go

@@ -0,0 +1,39 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+//go:build !nomanagers
+
+/*
+ * Copyright (C) 2026 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package configcore
+
+import "github.com/snapcore/snapd/strutil"
+
+func init() {
+	supportedConfigurations["core.system.disk-space-reservation"] = true
+}
+
+func validateDiskSpaceReservation(tr RunTransaction) error {
+	reservation, err := coreCfg(tr, "system.disk-space-reservation")
+	if err != nil {
+		return err
+	}
+	if reservation == "" {
+		return nil
+	}
+	_, err = strutil.ParseByteSize(reservation)
+	return err
+}

overlord/configstate/configcore/diskspace_test.go

@@ -0,0 +1,62 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+//go:build !nomanagers
+
+/*
+ * Copyright (C) 2026 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package configcore_test
+
+import (
+	. "gopkg.in/check.v1"
+
+	"github.com/snapcore/snapd/overlord/configstate/configcore"
+)
+
+type diskSpaceSuite struct {
+	configcoreSuite
+}
+
+var _ = Suite(&diskSpaceSuite{})
+
+func (s *diskSpaceSuite) TestConfigureDiskSpaceReservation(c *C) {
+	for _, tc := range []struct {
+		value any
+		err   string
+	}{
+		{value: ""},
+		{value: "0B"},
+		{value: "5242880B"},
+		{value: "5MB"},
+		{value: "1GB"},
+		{value: "5", err: `cannot parse "5": need a number with a unit as input`},
+		{value: "-1B", err: `cannot parse "-1B": size cannot be negative`},
+		{value: "bad", err: `cannot parse "bad": no numerical prefix`},
+		{value: "5MiB", err: `cannot parse "5MiB": try 'kB' or 'MB'`},
+	} {
+		err := configcore.Run(classicDev, &mockConf{
+			state: s.state,
+			changes: map[string]any{
+				"system.disk-space-reservation": tc.value,
+			},
+		})
+		if tc.err != "" {
+			c.Check(err, ErrorMatches, tc.err)
+		} else {
+			c.Check(err, IsNil)
+		}
+	}
+}

overlord/configstate/configcore/runwithstate.go

@@ -60,6 +60,7 @@ func init() {
 	addWithStateHandler(validateRefreshSchedule, nil, validateOnly)
 	addWithStateHandler(validateRefreshRateLimit, nil, validateOnly)
 	addWithStateHandler(validateAutomaticSnapshotsExpiration, nil, validateOnly)
+	addWithStateHandler(validateDiskSpaceReservation, nil, validateOnly)
 
 	// netplan.*
 	addWithStateHandler(validateNetplanSettings, handleNetplanConfiguration, coreOnly)

overlord/snapstate/autorefresh_gating_test.go

@@ -2274,7 +2274,7 @@ func (s *snapmgrTestSuite) testAutoRefreshPhase2DiskSpaceCheck(c *C, fail bool)
 	defer st.Unlock()
 
 	restore := snapstate.MockOsutilCheckFreeSpace(func(path string, sz uint64) error {
-		c.Check(sz, Equals, snapstate.SafetyMarginDiskSpace(123))
+		c.Check(sz, Equals, uint64(123)+snapstate.DefaultDiskSpaceReservation)
 		if fail {
 			return &osutil.NotEnoughDiskSpaceError{}
 		}

overlord/snapstate/export_test.go

@@ -129,7 +129,7 @@ var (
 
 	HasOtherInstances = hasOtherInstances
 
-	SafetyMarginDiskSpace = safetyMarginDiskSpace
+	DefaultDiskSpaceReservation = defaultDiskSpaceReservation
 
 	AffectedByRefresh = affectedByRefresh
 

overlord/snapstate/snapstate.go

@@ -91,6 +91,8 @@ var ErrNothingToDo = errors.New("nothing to do")
 
 var osutilCheckFreeSpace = osutil.CheckFreeSpace
 
+const defaultDiskSpaceReservation = uint64(5 * 1024 * 1024)
+
 // TestingLeaveOutKernelUpdateGadgetAssets can be used to simulate an upgrade
 // from a broken snapd that does not generate a "update-gadget-assets" task.
 // See LP:#1940553
@@ -172,9 +174,23 @@ func ShouldSendNotificationsToTheUser(st *state.State) (bool, error) {
 	return true, nil
 }
 
-// safetyMarginDiskSpace returns size plus a safety margin (5Mb)
-func safetyMarginDiskSpace(size uint64) uint64 {
-	return size + 5*1024*1024
+func diskSpaceReservation(tr *config.Transaction) uint64 {
+	var reservation string
+	err := tr.Get("core", "system.disk-space-reservation", &reservation)
+	if config.IsNoOption(err) {
+		// TODO: decide how unset system.disk-space-reservation should behave when
+		// the experimental disk space feature flags are graduated.
+		return defaultDiskSpaceReservation
+	}
+	if err != nil {
+		return 0
+	}
+
+	parsedReservation, err := strutil.ParseByteSize(reservation)
+	if err != nil {
+		return 0
+	}
+	return uint64(parsedReservation)
 }
 
 // ConfigureSnap returns a set of tasks to configure snapName as done during installation/refresh.
@@ -891,7 +907,7 @@ func downloadTasks(
 	if !skipSnapDownload {
 		// TODO:COMPS: support checking for available space for components
 		toDownloadTo := filepath.Dir(snapsup.BlobPath())
-		if err := checkDiskSpaceDownload([]minimalInstallInfo{installSnapInfo{info}}, toDownloadTo); err != nil {
+		if err := checkDiskSpaceDownload(st, []minimalInstallInfo{installSnapInfo{info}}, toDownloadTo); err != nil {
 			return nil, nil, err
 		}
 
@@ -2506,13 +2522,18 @@ func autoRefreshPhase2(st *state.State, candidates []*refreshCandidate, flags *F
 	return updateTss, nil
 }
 
-func checkDiskSpaceDownload(infos []minimalInstallInfo, rootDir string) error {
+func checkDiskSpaceDownload(st *state.State, infos []minimalInstallInfo, rootDir string) error {
+	reservation := diskSpaceReservation(config.NewTransaction(st))
+	if reservation == 0 {
+		return nil
+	}
+
 	var totalSize uint64
 	for _, info := range infos {
 		totalSize += uint64(info.DownloadSize())
 	}
 
-	return checkForAvailableSpace(totalSize, infos, "download", rootDir)
+	return checkForAvailableSpace(totalSize, reservation, infos, "download", rootDir)
 }
 
 // checkDiskSpace checks if there is enough space for the requested snaps and their prerequisites
@@ -2538,16 +2559,21 @@ func checkDiskSpace(st *state.State, changeKind string, infos []minimalInstallIn
 		return nil
 	}
 
+	reservation := diskSpaceReservation(tr)
+	if reservation == 0 {
+		return nil
+	}
+
 	totalSize, err := installSize(st, infos, userID, prqt)
 	if err != nil {
 		return err
 	}
 
-	return checkForAvailableSpace(totalSize, infos, changeKind, dirs.SnapdStateDir(dirs.GlobalRootDir))
+	return checkForAvailableSpace(totalSize, reservation, infos, changeKind, dirs.SnapdStateDir(dirs.GlobalRootDir))
 }
 
-func checkForAvailableSpace(totalSize uint64, infos []minimalInstallInfo, changeKind string, rootDir string) error {
-	requiredSpace := safetyMarginDiskSpace(totalSize)
+func checkForAvailableSpace(totalSize, reservation uint64, infos []minimalInstallInfo, changeKind string, rootDir string) error {
+	requiredSpace := totalSize + reservation
 	if err := osutilCheckFreeSpace(rootDir, requiredSpace); err != nil {
 		snaps := make([]string, len(infos))
 		for i, up := range infos {
@@ -3144,7 +3170,12 @@ func Remove(st *state.State, name string, revision snap.Revision, flags *RemoveF
 	// removeTasks() checks check-disk-space-remove feature flag, so snapshotSize
 	// will only be greater than 0 if the feature is enabled.
 	if snapshotSize > 0 {
-		requiredSpace := safetyMarginDiskSpace(snapshotSize)
+		reservation := diskSpaceReservation(config.NewTransaction(st))
+		if reservation == 0 {
+			return ts, err
+		}
+
+		requiredSpace := snapshotSize + reservation
 		path := dirs.SnapdStateDir(dirs.GlobalRootDir)
 		if err := osutilCheckFreeSpace(path, requiredSpace); err != nil {
 			if _, ok := err.(*osutil.NotEnoughDiskSpaceError); ok {
@@ -3296,7 +3327,7 @@ func removeTasks(st *state.State, snapst *SnapState, removals map[string]bool, r
 				if err != nil && !config.IsNoOption(err) {
 					return nil, 0, err
 				}
-				if checkDiskSpaceRemove {
+				if checkDiskSpaceRemove && diskSpaceReservation(tr) != 0 {
 					snapshotSize, err = EstimateSnapshotSize(st, instanceName, nil)
 					if err != nil {
 						return nil, 0, err
@@ -3579,7 +3610,12 @@ func RemoveMany(st *state.State, names []string, flags *RemoveFlags) ([]string,
 	// removeTasks() checks check-disk-space-remove feature flag, so totalSnapshotsSize
 	// will only be greater than 0 if the feature is enabled.
 	if totalSnapshotsSize > 0 {
-		requiredSpace := safetyMarginDiskSpace(totalSnapshotsSize)
+		reservation := diskSpaceReservation(config.NewTransaction(st))
+		if reservation == 0 {
+			return removed, tasksets, nil
+		}
+
+		requiredSpace := totalSnapshotsSize + reservation
 		if err := osutilCheckFreeSpace(path, requiredSpace); err != nil {
 			if _, ok := err.(*osutil.NotEnoughDiskSpaceError); ok {
 				return nil, nil, &InsufficientSpaceError{

overlord/snapstate/snapstate_install_test.go

@@ -3766,6 +3766,45 @@ func (s *snapmgrTestSuite) TestInstallDiskSpaceError(c *C) {
 	c.Check(diskSpaceErr.Snaps, DeepEquals, []string{"some-snap"})
 }
 
+func (s *snapmgrTestSuite) TestInstallConfigureDiskSpaceReservation(c *C) {
+	const freeDiskSpace = uint64(1500)
+	var requiredSizes []uint64
+	restore := snapstate.MockOsutilCheckFreeSpace(func(path string, sz uint64) error {
+		c.Check(path, Equals, filepath.Join(dirs.GlobalRootDir, "/var/lib/snapd"))
+		requiredSizes = append(requiredSizes, sz)
+		if sz > freeDiskSpace {
+			return &osutil.NotEnoughDiskSpaceError{}
+		}
+		return nil
+	})
+	defer restore()
+
+	restore = snapstate.MockInstallSize(func(st *state.State, snaps []snapstate.MinimalInstallInfo, userID int, prqt snapstate.PrereqTracker) (uint64, error) {
+		return 123, nil
+	})
+	defer restore()
+
+	s.state.Lock()
+	defer s.state.Unlock()
+
+	tr := config.NewTransaction(s.state)
+	tr.Set("core", "experimental.check-disk-space-install", true)
+	tr.Set("core", "system.disk-space-reservation", "2kB")
+	tr.Commit()
+
+	opts := &snapstate.RevisionOptions{Channel: "some-channel"}
+	_, err := snapstate.Install(context.Background(), s.state, "some-snap", opts, s.user.ID, snapstate.Flags{})
+	c.Assert(err, FitsTypeOf, &snapstate.InsufficientSpaceError{})
+
+	tr = config.NewTransaction(s.state)
+	tr.Set("core", "system.disk-space-reservation", "1kB")
+	tr.Commit()
+
+	_, err = snapstate.Install(context.Background(), s.state, "some-snap", opts, s.user.ID, snapstate.Flags{})
+	c.Assert(err, IsNil)
+	c.Check(requiredSizes, DeepEquals, []uint64{2123, 1123})
+}
+
 func (s *snapmgrTestSuite) TestInstallSizeError(c *C) {
 	restore := snapstate.MockInstallSize(func(st *state.State, snaps []snapstate.MinimalInstallInfo, userID int, prqt snapstate.PrereqTracker) (uint64, error) {
 		return 0, fmt.Errorf("boom")