C# P/Invoke | Inconsistent marshalling behaviour of array of blittable struct?

Question

I was testing around with P/Invoke stuff today and ran into something that greatly confuses me.

I have a unmanaged library with functions taking array parameters, printing out their values and modifying them:

#include <cstdio>

#define export extern "C" void __cdecl __declspec(dllexport)

struct S
{
    int x;
};

export PassIntArray(int* x, int size)
{
    for (int i = 0; i < size; i++)
    {
        printf("x[%i] = %i\n", i, x[i]);
        x[i] *= 10;
    }
}

export PassSArray(S* s, int size)
{
    for (int i = 0; i < size; i++)
    {
        printf("s[%i].x = %i\n", i, s[i].x);
        s[i].x *= 10;
    }
}

As well as a C# program accessing those function via P/Invoke:

using System.Runtime.InteropServices;
using static System.Console;

namespace Test
{
    [StructLayout(LayoutKind.Sequential)]
    struct S
    {
        public int X;
    }

    class Program
    {
        [DllImport("mylib.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PassIntArray(int[] x, int size);

        [DllImport("mylib.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PassSArray(S[] s, int size);

        static void Main(string[] args)
        {
            var z = new[] {1,2,3};
            PassIntArray(z, z.Length);
            foreach (var i in z)
                WriteLine(i);

            var u = new[] { new S { X = 1 }, new S { X = 2 }, new S { X = 3 } };
            PassSArray(u, u.Length);
            foreach (var i in u)
                WriteLine(i.X);
        }
    }
}

Running this program, the output for the array functions is as follows:

// Unmanaged side:
x[0] = 1
x[1] = 2
x[2] = 3
// Managed side, after modification:
10
20
30

But, for PassSArray, it's this:

// Unmanaged side:
s[0].x = 1
s[1].x = 2
s[2].x = 3
// Managed side, after modification:
1
2
3

From this question: "Happens when the value is blittable, an expensive word that means that the managed value or object layout is identical to the native layout. The pinvoke marshaller can then take a shortcut, pinning the object and passing a pointer to managed object storage. You'll inevitably see changes then since the native code is directly modifying the managed object."

From my understanding, S should be blittable (since it uses sequential layout and only contains fields of types which are blittable), and so should get pinned by the marshaller, causing modifications to 'carry over' as they do with PassIntArray. Where's the difference, and why?