windows-development-sandbox 1.7.0 → 1.10.0

package/sandbox/csharp/MemGov.cs

@@ -0,0 +1,466 @@
+// memgov.exe: the Windows side of the sandbox's memory governor (src/guest/governor). One long-running process the
+// daemon talks to over stdin/stdout, so the decisions stay in TypeScript and only the Win32 calls live here. C# 5.
+//
+//   stdout, a JSON line every --interval seconds (default 2):
+//     {"ramTotalMb":..,"ramAvailMb":..,"commitLimitMb":..,"commitAvailMb":..,"procs":[{"pid":..,"name":"rustc","mb":..,"prio":"normal"}]}
+//     procs = the processes in the agents' job (the job ptyhost makes for everything the agents start), nothing else.
+//   stdin, one command per line:
+//     priority <pid> <idle|below|normal>   lowers (or restores) the priority of a process in that job
+//     suspend <pid> <ms>                   pauses a process in that job, resumes it after ms (at most 30000)
+//     exit
+//
+// It only ever touches processes that are in the agents' job, never itself, and resumes everything it paused when it
+// ends or when the daemon goes away (stdin closes).
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+static class MemGov
+{
+    private const string AgentJobName = "Local\\AgentSandboxAgentsJob";
+    private const double BytesPerMb = 1024.0 * 1024.0;
+    private const int MaxProcesses = 1024;
+    private const int MaxSuspendMs = 30000;
+    private const uint JobObjectQuery = 0x0004;
+    private const int JobObjectBasicProcessIdList = 3;
+    private const uint ProcessQueryLimited = 0x1000;
+    private const uint ProcessSetInformation = 0x0200;
+    private const uint ProcessSuspendResume = 0x0800;
+    private const uint IdleClass = 0x00000040;
+    private const uint BelowNormalClass = 0x00004000;
+    private const uint NormalClass = 0x00000020;
+
+    // MEMORYSTATUSEX.
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryStatus
+    {
+        public uint Length;
+        public uint MemoryLoad;
+        public ulong TotalPhys;
+        public ulong AvailPhys;
+        public ulong TotalPageFile;
+        public ulong AvailPageFile;
+        public ulong TotalVirtual;
+        public ulong AvailVirtual;
+        public ulong AvailExtendedVirtual;
+    }
+
+    private static class NativeMethods
+    {
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool GlobalMemoryStatusEx(ref MemoryStatus status);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern IntPtr OpenJobObjectW(uint access, bool inherit, string name);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool QueryInformationJobObject(IntPtr job, int infoClass, IntPtr info, int length, IntPtr returnLength);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool IsProcessInJob(IntPtr process, IntPtr job, out bool result);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetPriorityClass(IntPtr process, uint priorityClass);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern uint GetPriorityClass(IntPtr process);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool CloseHandle(IntPtr handle);
+
+        [DllImport("ntdll.dll")]
+        public static extern int NtSuspendProcess(IntPtr process);
+
+        [DllImport("ntdll.dll")]
+        public static extern int NtResumeProcess(IntPtr process);
+    }
+
+    private static readonly object Gate = new object();
+    private static readonly Dictionary<int, DateTime> Paused = new Dictionary<int, DateTime>();
+
+    /// <summary>The paused process ids on disk, so a memgov that is killed mid-pause is undone by the next one.</summary>
+    private static readonly string HeldFile = Path.Combine(Path.GetTempPath(), "agent-sandbox-memgov-held.txt");
+    private static IntPtr job = IntPtr.Zero;
+    private static volatile bool stop;
+
+    static int Main(string[] args)
+    {
+        if (args.Length == 0 || args[0] != "serve")
+        {
+            Console.Error.WriteLine("usage: memgov serve [--interval seconds]");
+            return 2;
+        }
+        int interval = 2;
+        for (int i = 1; i + 1 < args.Length; i++)
+        {
+            if (args[i] == "--interval")
+            {
+                int.TryParse(args[i + 1], NumberStyles.Integer, CultureInfo.InvariantCulture, out interval);
+            }
+        }
+        if (interval < 1)
+        {
+            interval = 2;
+        }
+        // A memgov that ended without resuming (killed, crashed) left its pauses in the file: undo them first.
+        RecoverHeld();
+        Thread commands = new Thread(ReadCommands);
+        commands.IsBackground = true;
+        commands.Start();
+        Thread resumer = new Thread(ResumeWhenDue);
+        resumer.IsBackground = true;
+        resumer.Start();
+        while (!stop)
+        {
+            try
+            {
+                Console.Out.WriteLine(Sample());
+                Console.Out.Flush();
+            }
+            catch (Exception)
+            {
+                // A sample that fails (a process ended while it was read) is skipped; the next one tries again.
+            }
+            for (int waited = 0; waited < interval * 10 && !stop; waited++)
+            {
+                Thread.Sleep(100);
+            }
+        }
+        ResumeAll();
+        return 0;
+    }
+
+    /// <summary>The job, opened once it exists (ptyhost makes it when the first agent starts).</summary>
+    private static IntPtr Job()
+    {
+        if (job == IntPtr.Zero)
+        {
+            job = NativeMethods.OpenJobObjectW(JobObjectQuery, false, AgentJobName);
+        }
+        return job;
+    }
+
+    private static string Sample()
+    {
+        MemoryStatus status = new MemoryStatus();
+        status.Length = (uint)Marshal.SizeOf(typeof(MemoryStatus));
+        if (!NativeMethods.GlobalMemoryStatusEx(ref status))
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.Append("{\"ramTotalMb\":").Append(Mb(status.TotalPhys));
+        sb.Append(",\"ramAvailMb\":").Append(Mb(status.AvailPhys));
+        sb.Append(",\"commitLimitMb\":").Append(Mb(status.TotalPageFile));
+        sb.Append(",\"commitAvailMb\":").Append(Mb(status.AvailPageFile));
+        sb.Append(",\"procs\":[");
+        bool first = true;
+        int self = Process.GetCurrentProcess().Id;
+        foreach (int pid in JobProcessIds())
+        {
+            if (pid == self)
+            {
+                continue;
+            }
+            try
+            {
+                using (Process p = Process.GetProcessById(pid))
+                {
+                    if (!first)
+                    {
+                        sb.Append(',');
+                    }
+                    first = false;
+                    sb.Append("{\"pid\":").Append(pid.ToString(CultureInfo.InvariantCulture));
+                    sb.Append(",\"name\":").Append(Json(p.ProcessName));
+                    sb.Append(",\"mb\":").Append(Mb((ulong)p.PrivateMemorySize64));
+                    sb.Append(",\"prio\":\"").Append(PriorityName(pid)).Append("\"}");
+                }
+            }
+            catch (Exception)
+            {
+                // The process ended while it was read.
+            }
+        }
+        return sb.Append("]}").ToString();
+    }
+
+    private static List<int> JobProcessIds()
+    {
+        List<int> ids = new List<int>();
+        IntPtr handle = Job();
+        if (handle == IntPtr.Zero)
+        {
+            return ids;
+        }
+        // JOBOBJECT_BASIC_PROCESS_ID_LIST: two counts, then the ids (pointer-sized).
+        int length = 8 + IntPtr.Size * MaxProcesses;
+        IntPtr buffer = Marshal.AllocHGlobal(length);
+        try
+        {
+            if (!NativeMethods.QueryInformationJobObject(handle, JobObjectBasicProcessIdList, buffer, length, IntPtr.Zero))
+            {
+                return ids;
+            }
+            int count = Marshal.ReadInt32(buffer, 4);
+            for (int i = 0; i < count && i < MaxProcesses; i++)
+            {
+                ids.Add((int)Marshal.ReadIntPtr(buffer, 8 + i * IntPtr.Size).ToInt64());
+            }
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+        return ids;
+    }
+
+    private static string PriorityName(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessQueryLimited, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return "normal";
+        }
+        try
+        {
+            uint c = NativeMethods.GetPriorityClass(process);
+            return c == IdleClass ? "idle" : c == BelowNormalClass ? "below" : "normal";
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>Whether pid is a process of the agents' job and not this one: the only ones this program touches.</summary>
+    private static bool Allowed(int pid)
+    {
+        return pid != Process.GetCurrentProcess().Id && JobProcessIds().Contains(pid);
+    }
+
+    private static void ReadCommands()
+    {
+        string line;
+        while ((line = Console.In.ReadLine()) != null)
+        {
+            try
+            {
+                Run(line.Trim().Split(' '));
+            }
+            catch (Exception)
+            {
+                // A bad command is ignored.
+            }
+            if (stop)
+            {
+                return;
+            }
+        }
+        // The daemon is gone: put everything back and end.
+        stop = true;
+    }
+
+    private static void Run(string[] parts)
+    {
+        if (parts.Length == 1 && parts[0] == "exit")
+        {
+            stop = true;
+            return;
+        }
+        int pid;
+        if (parts.Length < 3 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        {
+            return;
+        }
+        if (parts[0] == "priority")
+        {
+            uint cls = parts[2] == "idle" ? IdleClass : parts[2] == "below" ? BelowNormalClass : NormalClass;
+            IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
+            if (process != IntPtr.Zero)
+            {
+                NativeMethods.SetPriorityClass(process, cls);
+                NativeMethods.CloseHandle(process);
+            }
+        }
+        else if (parts[0] == "suspend")
+        {
+            int ms;
+            if (!int.TryParse(parts[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out ms) || ms < 1)
+            {
+                return;
+            }
+            Suspend(pid, Math.Min(ms, MaxSuspendMs));
+        }
+    }
+
+    private static void Suspend(int pid, int ms)
+    {
+        lock (Gate)
+        {
+            if (Paused.ContainsKey(pid))
+            {
+                return;
+            }
+            IntPtr process = NativeMethods.OpenProcess(ProcessSuspendResume, false, pid);
+            if (process == IntPtr.Zero)
+            {
+                return;
+            }
+            try
+            {
+                // Recorded before the pause, so a memgov that dies right after still lets the next one resume it.
+                Paused[pid] = DateTime.UtcNow.AddMilliseconds(ms);
+                SaveHeld();
+                NativeMethods.NtSuspendProcess(process);
+            }
+            finally
+            {
+                NativeMethods.CloseHandle(process);
+            }
+        }
+    }
+
+    private static void Resume(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSuspendResume, false, pid);
+        if (process != IntPtr.Zero)
+        {
+            NativeMethods.NtResumeProcess(process);
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>A paused process always comes back: when its time is up (checked every 100 ms).</summary>
+    private static void ResumeWhenDue()
+    {
+        while (true)
+        {
+            Thread.Sleep(100);
+            lock (Gate)
+            {
+                List<int> due = new List<int>();
+                foreach (KeyValuePair<int, DateTime> p in Paused)
+                {
+                    if (p.Value <= DateTime.UtcNow)
+                    {
+                        due.Add(p.Key);
+                    }
+                }
+                foreach (int pid in due)
+                {
+                    Resume(pid);
+                    Paused.Remove(pid);
+                }
+                if (due.Count > 0)
+                {
+                    SaveHeld();
+                }
+            }
+        }
+    }
+
+    private static void ResumeAll()
+    {
+        lock (Gate)
+        {
+            foreach (int pid in new List<int>(Paused.Keys))
+            {
+                Resume(pid);
+            }
+            Paused.Clear();
+            SaveHeld();
+        }
+    }
+
+    /// <summary>The processes paused right now, one id per line (empty: the file goes). Called with Gate held.</summary>
+    private static void SaveHeld()
+    {
+        try
+        {
+            if (Paused.Count == 0)
+            {
+                File.Delete(HeldFile);
+                return;
+            }
+            List<string> lines = new List<string>();
+            foreach (int pid in Paused.Keys)
+            {
+                lines.Add(pid.ToString(CultureInfo.InvariantCulture));
+            }
+            File.WriteAllLines(HeldFile, lines.ToArray());
+        }
+        catch (IOException)
+        {
+            // Best effort: the in-memory list still resumes every pause while this memgov runs.
+        }
+        catch (UnauthorizedAccessException)
+        {
+            // Same as above.
+        }
+    }
+
+    /// <summary>Resumes what an earlier memgov paused and never resumed. Resuming a running process changes nothing.</summary>
+    private static void RecoverHeld()
+    {
+        try
+        {
+            if (!File.Exists(HeldFile))
+            {
+                return;
+            }
+            foreach (string line in File.ReadAllLines(HeldFile))
+            {
+                int pid;
+                if (int.TryParse(line.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) && pid > 0)
+                {
+                    Resume(pid);
+                }
+            }
+            File.Delete(HeldFile);
+        }
+        catch (IOException)
+        {
+            // Nothing more to do: the file stays and the next start tries again.
+        }
+        catch (UnauthorizedAccessException)
+        {
+            // Same as above.
+        }
+    }
+
+    private static string Mb(ulong bytes)
+    {
+        return Math.Floor(bytes / BytesPerMb).ToString("0", CultureInfo.InvariantCulture);
+    }
+
+    private static string Json(string value)
+    {
+        StringBuilder sb = new StringBuilder("\"");
+        foreach (char c in value)
+        {
+            if (c == '"' || c == '\\')
+            {
+                sb.Append('\\').Append(c);
+            }
+            else if (c < 0x20)
+            {
+                sb.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+            }
+            else
+            {
+                sb.Append(c);
+            }
+        }
+        return sb.Append('"').ToString();
+    }
+}

package/sandbox/csharp/PtyHost.cs

@@ -79,7 +79,7 @@ sealed class SessionHost
         log.Write("starting: " + command);
         while (true)
         {
-            using (PseudoConsole console = PseudoConsole.Start(command, hub.Cols, hub.Rows, hub.Broadcast))
+            using (PseudoConsole console = PseudoConsole.Start(command, hub.Cols, hub.Rows, hub.Broadcast, log))
             {
                 hub.Attach(console);
                 log.Write("pseudo console: " + Native.ConsoleKind);
@@ -856,7 +856,7 @@ sealed class PseudoConsole : IDisposable
         this.pump = pump;
     }
 
-    public static PseudoConsole Start(string commandLine, short cols, short rows, Action<byte[]> onOutput)
+    public static PseudoConsole Start(string commandLine, short cols, short rows, Action<byte[]> onOutput, Log log)
     {
         SafeFileHandle inRead;
         SafeFileHandle inWrite;
@@ -872,7 +872,7 @@ sealed class PseudoConsole : IDisposable
         }
         inRead.Dispose();
         outWrite.Dispose();
-        IntPtr process = Native.Spawn(commandLine, handle);
+        IntPtr process = Native.Spawn(commandLine, handle, log);
         FileStream output = new FileStream(outRead, FileAccess.Read);
         Thread pump = new Thread(() => Pump(output, onOutput));
         pump.IsBackground = true;
@@ -1085,6 +1085,12 @@ sealed class Log
 static class Native
 {
     private const uint ExtendedStartupInfoPresent = 0x00080000;
+    private const uint CreateSuspended = 0x00000004;
+    // The shared job of everything the agents start (the memory governor in the daemon opens it by this name).
+    private const string AgentJobName = "Local\\AgentSandboxAgentsJob";
+    private const int JobObjectExtendedLimitInformation = 9;
+    private const uint JobObjectLimitJobMemory = 0x00000200;
+    private const long BytesPerMb = 1024L * 1024L;
     private const int UseStdHandles = 0x00000100;
     private static readonly IntPtr PseudoConsoleAttribute = (IntPtr)0x00020016;
 
@@ -1125,6 +1131,43 @@ static class Native
         public IntPtr lpAttributeList;
     }
 
+    // JOBOBJECT_BASIC_LIMIT_INFORMATION, IO_COUNTERS and JOBOBJECT_EXTENDED_LIMIT_INFORMATION.
+    [StructLayout(LayoutKind.Sequential)]
+    private struct JobBasicLimit
+    {
+        public long PerProcessUserTimeLimit;
+        public long PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint PriorityClass;
+        public uint SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct IoCounters
+    {
+        public ulong ReadOperationCount;
+        public ulong WriteOperationCount;
+        public ulong OtherOperationCount;
+        public ulong ReadTransferCount;
+        public ulong WriteTransferCount;
+        public ulong OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct JobExtendedLimit
+    {
+        public JobBasicLimit BasicLimitInformation;
+        public IoCounters IoInfo;
+        public UIntPtr ProcessMemoryLimit;
+        public UIntPtr JobMemoryLimit;
+        public UIntPtr PeakProcessMemoryUsed;
+        public UIntPtr PeakJobMemoryUsed;
+    }
+
     [StructLayout(LayoutKind.Sequential)]
     private struct ProcessInformation
     {
@@ -1182,6 +1225,18 @@ static class Native
         [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
         public static extern bool CreateProcessW(string lpApplicationName, StringBuilder lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, ref StartupInfoEx lpStartupInfo, out ProcessInformation lpProcessInformation);
 
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref JobExtendedLimit info, int length);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern uint ResumeThread(IntPtr thread);
+
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
 
@@ -1241,9 +1296,51 @@ static class Native
         return NativeMethods.CreatePipe(out read, out write, IntPtr.Zero, 0);
     }
 
+    private static IntPtr agentJob;
+    private static bool agentJobTried;
+
+    /// <summary>
+    /// The shared job of everything the agents start, with a memory limit for all of it together (PTYHOST_JOB_MB, set
+    /// by the daemon from sandbox.agentMemoryHeadroomMb): a runaway build then gets out-of-memory errors in its own
+    /// session instead of using up the whole sandbox. Zero when no limit is asked for or the job cannot be made; ptyhost
+    /// itself is never in it. The handle stays open for ptyhost's whole life (the job lives while a handle is open).
+    /// </summary>
+    private static IntPtr AgentJob(Log log)
+    {
+        if (agentJobTried)
+        {
+            return agentJob;
+        }
+        agentJobTried = true;
+        long limitMb;
+        if (!long.TryParse(Environment.GetEnvironmentVariable("PTYHOST_JOB_MB"), out limitMb) || limitMb < 512)
+        {
+            return IntPtr.Zero;
+        }
+        IntPtr job = NativeMethods.CreateJobObjectW(IntPtr.Zero, AgentJobName);
+        if (job == IntPtr.Zero)
+        {
+            log.Write("agent job: CreateJobObject failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
+            return IntPtr.Zero;
+        }
+        JobExtendedLimit info = new JobExtendedLimit();
+        info.BasicLimitInformation.LimitFlags = JobObjectLimitJobMemory;
+        info.JobMemoryLimit = new UIntPtr((ulong)(limitMb * BytesPerMb));
+        if (!NativeMethods.SetInformationJobObject(job, JobObjectExtendedLimitInformation, ref info, Marshal.SizeOf(typeof(JobExtendedLimit))))
+        {
+            log.Write("agent job: setting the limit failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
+            NativeMethods.CloseHandle(job);
+            return IntPtr.Zero;
+        }
+        log.Write("agent job: everything the agent starts may use " + limitMb + " MB together");
+        agentJob = job;
+        return job;
+    }
+
     /// <summary>Starts `commandLine` attached to the pseudo console. Null std handles: never leak our own stdio into the child.</summary>
-    public static IntPtr Spawn(string commandLine, IntPtr pseudoConsole)
+    public static IntPtr Spawn(string commandLine, IntPtr pseudoConsole, Log log)
     {
+        IntPtr job = AgentJob(log);
         IntPtr size = IntPtr.Zero;
         NativeMethods.InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref size);
         IntPtr attributes = Marshal.AllocHGlobal(size);
@@ -1256,10 +1353,19 @@ static class Native
             info.StartupInfo.dwFlags = UseStdHandles;
             info.lpAttributeList = attributes;
             ProcessInformation pi;
-            if (!NativeMethods.CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, ExtendedStartupInfoPresent, IntPtr.Zero, null, ref info, out pi))
+            if (!NativeMethods.CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, ExtendedStartupInfoPresent | (job != IntPtr.Zero ? CreateSuspended : 0), IntPtr.Zero, null, ref info, out pi))
             {
                 throw new IOException("CreateProcess failed (" + Marshal.GetLastWin32Error() + "): " + commandLine);
             }
+            if (job != IntPtr.Zero)
+            {
+                // Suspended until it is in the job, so nothing it starts can be outside.
+                if (!NativeMethods.AssignProcessToJobObject(job, pi.hProcess))
+                {
+                    log.Write("agent job: could not add the agent (" + Marshal.GetLastWin32Error() + "); it runs without the memory limit");
+                }
+                NativeMethods.ResumeThread(pi.hThread);
+            }
             NativeMethods.CloseHandle(pi.hThread);
             return pi.hProcess;
         }

package/sandbox/scripts/new-shortcuts.ps1

@@ -5,7 +5,9 @@ param([Parameter(Mandatory = $true)][string]$ListFile)
 $ErrorActionPreference = 'Stop'
 
 $shell = New-Object -ComObject WScript.Shell
-foreach ($entry in @(Get-Content -LiteralPath $ListFile -Raw -Encoding UTF8 | ConvertFrom-Json)) {
+# Windows PowerShell 5.1 hands a JSON array over as ONE object: pipe it through ForEach-Object to get its elements.
+$entries = @(ConvertFrom-Json -InputObject (Get-Content -LiteralPath $ListFile -Raw -Encoding UTF8) | ForEach-Object { $_ })
+foreach ($entry in $entries) {
     New-Item -ItemType Directory -Force -Path (Split-Path -Parent $entry.link) | Out-Null
     $shortcut = $shell.CreateShortcut($entry.link)
     $shortcut.TargetPath = $entry.target