runc: Runc init process step on DISK Sleep Status When freezen cgroup

I think we should not return FREEZING as a state as no one expects it. Here’s my attempt at solving this:

diff --git a/libcontainer/cgroups/fs/freezer.go b/libcontainer/cgroups/fs/freezer.go
index 11cb1646..dc265d7f 100644
--- a/libcontainer/cgroups/fs/freezer.go
+++ b/libcontainer/cgroups/fs/freezer.go
@@ -28,33 +28,40 @@ func (s *FreezerGroup) Apply(path string, d *cgroupData) error {
 
 func (s *FreezerGroup) Set(path string, cgroup *configs.Cgroup) error {
        switch cgroup.Resources.Freezer {
-       case configs.Frozen, configs.Thawed:
-               for {
-                       // In case this loop does not exit because it doesn't get the expected
-                       // state, let's write again this state, hoping it's going to be properly
-                       // set this time. Otherwise, this loop could run infinitely, waiting for
-                       // a state change that would never happen.
-                       if err := fscommon.WriteFile(path, "freezer.state", string(cgroup.Resources.Freezer)); err != nil {
+       case configs.Frozen:
+               // As per kernel doc (freezer-subsystem.txt), if FREEZING
+               // is seen, userspace should either retry or thaw.
+               for i := 0; i < 10; i++ {
+                       if err := fscommon.WriteFile(path, "freezer.state", string(configs.Frozen)); err != nil {
                                return err
                        }
 
-                       state, err := s.GetState(path)
+                       state, err := fscommon.ReadFile(path, "freezer.state")
                        if err != nil {
                                return err
                        }
-                       if state == cgroup.Resources.Freezer {
-                               break
+                       state = strings.TrimSpace(state)
+                       switch state {
+                       case "FREEZING":
+                               time.Sleep(time.Duration(i) * time.Millisecond)
+                               continue
+                       case string(configs.Frozen):
+                               return nil
+                       default:
+                               return fmt.Errorf("unexpected state %s while freezing", strings.TrimSpace(state))
                        }
-
-                       time.Sleep(1 * time.Millisecond)
                }
+               // It got stuck in FREEZING. Try to thaw it back
+               // (which will most probably succeed) and error out.
+               _ = fscommon.WriteFile(path, "freezer.state", string(configs.Thawed))
+               return errors.New("unable to freeze")
+       case configs.Thawed:
+               return fscommon.WriteFile(path, "freezer.state", string(configs.Thawed))
        case configs.Undefined:
                return nil
        default:
                return fmt.Errorf("Invalid argument '%s' to freezer.state", string(cgroup.Resources.Freezer))
        }
-
-       return nil
 }
 
 func (s *FreezerGroup) GetStats(path string, stats *cgroups.Stats) error {

This way, GetState() does not need to be changed as it will eventually succeed.