Disabling Lua GC while persisting and unpersisting, might help with native crash.

src/main/resources/assets/opencomputers/lua/kernel.lua

@@ -41,6 +41,25 @@ local function spcall(...)
   end
 end
 
+local function sgc(self)
+  local oldDeadline, oldHitDeadline = deadline, hitDeadline
+  local mt = debug.getmetatable(self)
+  mt = rawget(mt, "mt")
+  local gc = rawget(mt, "__gc")
+  if type(gc) ~= "function" then
+    return
+  end
+  local co = coroutine.create(gc)
+  debug.sethook(co, checkDeadline, "", hookInterval)
+  deadline, hitDeadline = math.min(oldDeadline, computer.realTime() + 0.5), true
+  local result, reason = coroutine.resume(co, self)
+  debug.sethook(co)
+  deadline, hitDeadline = oldDeadline, oldHitDeadline
+  if not result then
+    error(reason, 0)
+  end
+end
+
 --[[ This is the global environment we make available to userland programs. ]]
 -- You'll notice that we do a lot of wrapping of native functions and adding
 -- parameter checks in those wrappers. This is to avoid errors from the host
@@ -53,8 +72,15 @@ sandbox = {
   error = error,
   _G = nil, -- see below
   getmetatable = function(t)
-    if type(t) == "string" then return nil end
+    if type(t) == "string" then -- don't allow messing with the string mt
-    return getmetatable(t)
+      return nil
+    end
+    local result = getmetatable(t)
+    -- check if we have a wrapped __gc using mt
+    if type(result) == "table" and rawget(result, "__gc") == sgc then
+      result = rawget(result, "mt")
+    end
+    return result
   end,
   ipairs = ipairs,
   load = function(ld, source, mode, env)
@@ -81,29 +107,21 @@ sandbox = {
     if type(mt) ~= "table" then
       return setmetatable(t, mt)
     end
-    local gc = rawget(mt, "__gc")
+    if type(rawget(mt, "__gc")) == "function" then
-    if type(gc) == "function" then
       -- For all user __gc functions we enforce a much tighter deadline.
       -- This is because these functions may be called from the main
       -- thread under certain circumstanced (such as when saving the world),
       -- which can lead to noticeable lag if the __gc function behaves badly.
-      rawset(mt, "__gc", function(self)
+      local sbmt = {} -- sandboxed metatable. only for __gc stuff, so it's
-        local oldDeadline, oldHitDeadline = deadline, hitDeadline
+                      -- kinda ok to have a shallow copy instead... meh.
-        local co = coroutine.create(gc)
+      for k, v in pairs(mt) do
-        debug.sethook(co, checkDeadline, "", hookInterval)
+        sbmt[k] = v
-        deadline, hitDeadline = math.min(oldDeadline, computer.realTime() + 0.5), true
-        local result, reason = coroutine.resume(co, self)
-        debug.sethook(co)
-        checkDeadline()
-        deadline, hitDeadline = oldDeadline, oldHitDeadline
-        if not result then
-          error(reason, 0)
       end
-      end)
+      sbmt.mt = mt
+      sbmt.__gc = sgc
+      mt = sbmt
     end
-    local result = setmetatable(t, mt)
+    return setmetatable(t, mt)
-    rawset(mt, "__gc", gc)
-    return result
   end,
   tonumber = tonumber,
   tostring = tostring,

src/main/scala/li/cil/oc/server/component/machine/NativeLuaArchitecture.scala

@@ -347,9 +347,15 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
       for (api <- apis) {
         api.load(nbt)
       }
+
+      try lua.gc(LuaState.GcAction.COLLECT, 0) catch {
+        case t: Throwable =>
+          OpenComputers.log.warning(s"Error cleaning up loaded computer @ (${machine.owner.x}, ${machine.owner.y}, ${machine.owner.z}). This either means the server is badly overloaded or a user created an evil __gc method, accidentally or not.")
+          machine.crash("error in garbage collector, most likely __gc method timed out")
+      }
     } catch {
       case e: LuaRuntimeException =>
-        OpenComputers.log.warning("Could not unpersist computer.\n" + e.toString + (if (e.getLuaStackTrace.isEmpty) "" else "\tat " + e.getLuaStackTrace.mkString("\n\tat ")))
+        OpenComputers.log.warning(s"Could not unpersist computer @ (${machine.owner.x}, ${machine.owner.y}, ${machine.owner.z}).\n${e.toString}" + (if (e.getLuaStackTrace.isEmpty) "" else "\tat " + e.getLuaStackTrace.mkString("\n\tat ")))
         machine.stop()
         machine.start()
     }
@@ -386,6 +392,12 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
       for (api <- apis) {
         api.save(nbt)
       }
+
+      try lua.gc(LuaState.GcAction.COLLECT, 0) catch {
+        case t: Throwable =>
+          OpenComputers.log.warning(s"Error cleaning up loaded computer @ (${machine.owner.x}, ${machine.owner.y}, ${machine.owner.z}). This either means the server is badly overloaded or a user created an evil __gc method, accidentally or not.")
+          machine.crash("error in garbage collector, most likely __gc method timed out")
+      }
     } catch {
       case e: LuaRuntimeException =>
         OpenComputers.log.warning(s"Could not persist computer @ (${machine.owner.x}, ${machine.owner.y}, ${machine.owner.z}).\n${e.toString}" + (if (e.getLuaStackTrace.isEmpty) "" else "\tat " + e.getLuaStackTrace.mkString("\n\tat ")))

src/main/scala/li/cil/oc/server/component/machine/luac/PersistenceAPI.scala

@@ -122,6 +122,8 @@ class PersistenceAPI(owner: NativeLuaArchitecture) extends NativeLuaAPI(owner) {
   def persist(index: Int): Array[Byte] = {
     if (Settings.get.allowPersistence) {
       configure()
+      try {
+        lua.gc(LuaState.GcAction.STOP, 0)
         lua.getGlobal("eris") // ... eris
         lua.getField(-1, "persist") // ... eris persist
         if (lua.isFunction(-1)) {
@@ -143,12 +145,18 @@ class PersistenceAPI(owner: NativeLuaArchitecture) extends NativeLuaAPI(owner) {
         } // ... eris :(
         lua.pop(2) // ...
       }
+      finally {
+        lua.gc(LuaState.GcAction.RESTART, 0)
+      }
+    }
     Array[Byte]()
   }
 
   def unpersist(value: Array[Byte]): Boolean = {
     if (Settings.get.allowPersistence) {
       configure()
+      try {
+        lua.gc(LuaState.GcAction.STOP, 0)
         lua.getGlobal("eris") // ... eris
         lua.getField(-1, "unpersist") // ... eris unpersist
         if (lua.isFunction(-1)) {
@@ -161,6 +169,10 @@ class PersistenceAPI(owner: NativeLuaArchitecture) extends NativeLuaAPI(owner) {
         } // ... :(
         lua.pop(1)
       }
+      finally {
+        lua.gc(LuaState.GcAction.RESTART, 0)
+      }
+    }
     false
   }
 }