"free() function" csak egyszer működik.

Máshogy néz ki. A standard C világkép úgy néz ki, hogy a program adatterületének az egyik végétől nő a malloc() által visszadott "új" világ. Először kb. nulla a mérete, de ahogy allokálgatsz, úgy növeszti a program az operációs rendszertől elkért (belapozott) terület méretét. A malloc() ebből egy-egy darabra ad vissza mutatókat. A felszabadítás viszont csak a program saját hatáskörében történik, azaz a felszabadított területet soha nem adja vissza az operációs rendszernek a program, a már belapozott terület sosem lapozódik ki. Azaz a free() után továbbra is ottmarad a memória, és amíg másra nem allokálod, és felül nem írod, addig még a tartalma is változatlan marad.

Természetesen a malloc/free() implementáció működése ebből a szempontból a környezet belügye, _akár_ meg is írhatják olyanra, hogy adjon vissza memóriaterületeket az operációs rendszernek, de szerintem ez nem standard működés, mivel nyilvánvalóan lassítja a programot már pusztán csak annak a felismerése, hogy lehet-e bármit visszaadni, lévén a lapozás legalább page méretekben történhet, a malloc() pedig ennél kisebb darabokat is kezel.

A kernel ahogy írtad is, a virtual memory-n keresztűl fizikai memóriát fog a progi alá adni. Viszont ha te egyszer 255 byte -ot foglalsz, akkor is egy teljes page kerül alád (a következő 255 byte malloc pedig majd ugyan ebbe a page-be kerül míg van benne hely, aztán kapsz másikat ha elfogyott). Ráadásként a free -vel valóban felszabadítod a memóriát, amit később újrafoglalhatsz, viszont a free nem jelenti azt hogy azonnal visszakerül a kernel kezébe a page, így ha később véletlen bele is írsz, nem biztos hogy azonnal segmentation fault az eredménye. Ráadásként ezek erősen allocator függő dolgok, a tcmalloc -nak pl rá kell csapni a kezére időnként hogy legalább a kernelig visszapasszolja az általa lefoglalt területeket

// Happy debugging, suckers
#define true (rand() > 10)

A malloc(3)-ból nem feltétlenül lesz rendszerhívás (sbrk(2) vagy mmap(2)), a free-ből pedig még ritkábban... tipikusan a libc illetékes része a free(3) után is megtartja a memóriát későbbi használatra.

Icipicit módosítottam a kódon:

void main( int argc, char* argv[]) {
   char *String;

   String = (char *) malloc(255);

   strcpy(String, "Valami1");
   printf("String = %s\n", String);
   printf("StringP = %x\n", String);
   free(String);

   printf("- - - - - - - - - -\n");

   printf("StringP = %x\n", String);
   for ( int i=0; i<atoi(argv[1]); ++i) {
      printf("%d\n", i);
      strcpy( String + i*10, "0123456789");
   }
   printf("String: %s\n", String);
}

Aztán elkezdtem hívogatni 10 hatványaival.
10000-ezerig simán elment (noha 255 bájtos volt a foglalás), de végül beteljesedett a sorsa 100000-rel:

13514
13515
Segmentation fault (core dumped)

Vagyis vagy tényleg szabad hülyének lenni a heapen, vagy (ezt sem merem kizárni) mostanában, amikor ANNYI a RAM, a kernel alattomosan provízionál akkor is, ha senki sem kéri.