lib/ramfs: Ensure stability of inode numbers

[andreittr]

Description of changes

Previously ramfs would assign a new unique inode number to a file on every successful filesystem lookup. This can lead to the same file being allocated multiple different inodes, breaking code that (correctly) uses inodes as reliable indicators of file identity.
This change makes inode numbers persistent, allocated along with the filesystem node, and stable across multiple lookups of the same file.

Prerequisite checklist

• Read the contribution guidelines regarding submitting new changes to the project;
• Tested your changes against relevant architectures and platforms;
• Ran the checkpatch.uk on your commit series before opening this PR;
• Updated relevant documentation.

Base target

• Architecture(s): N/A
• Platform(s): N/A
• Application(s): N/A

Additional configuration

Test with:

int f = open("file", O_RDONLY);
fstat(f, &st1);
stat("file", &st2);
printf("Should be same: %ld %ld\n", st1.st_ino, st2.st_ino);

[RaduNichita]

This seems OK, thanks @andreittr! I left some minor nitpicks

[RaduNichita]

Please add a comment about the need for this member in the structure.

[RaduNichita]

Why have an empty line before?

[RaduNichita]

@andreittr, is it intended to open the file without the O_CREAT flag?

I am asking this since for Linux, it creates a file, but the inode number differs at the second attempt or running (0 vs a large number).

[andreittr]

@andreittr, is it intended to open the file without the O_CREAT flag?

I am asking this since for Linux, it creates a file, but the inode number differs at the second attempt or running (0 vs a large number).

Yes, the test snippet assumes "file" exists and is a regular file created ahead of time (e.g. already included in the ramfs/initrd)

[mariasfiraiala]

@andreittr The changes look fine, however I wasn't able to reproduce the issue. Could you please share a bit more regarding your setup?

This is what I've tested:

int main(void)
{
	struct stat st1 = {0};
	struct stat st2 = {0};

	int f = open("file", O_CREAT);
	fstat(f, &st1);
	stat("file", &st2);
	printf("Should be same: %ld %ld\n", st1.st_ino, st2.st_ino);
}

And this is the output:

Notice how the break point at which the static variable should be incremented is reached only once.

[andreittr]

@andreittr The changes look fine, however I wasn't able to reproduce the issue. Could you please share a bit more regarding your setup?

This is what I've tested:

int main(void)
{
	struct stat st1 = {0};
	struct stat st2 = {0};

	int f = open("file", O_CREAT);
	fstat(f, &st1);
	stat("file", &st2);
	printf("Should be same: %ld %ld\n", st1.st_ino, st2.st_ino);
}

And this is the output:

Notice how the break point at which the static variable should be incremented is reached only once.

Hi! See the above comment as well as the test snippet in the description. open() is not supposed to be called with O_CREAT, rather just with O_RDONLY and "file" needs to already exist. This is necessary to cause multiple FS lookups of the file, resulting in different inode numbers.

[andreittr]

Pushed changes addressing comments.

[mariasfiraiala]

I see, all good on my side, then. Let's merge this!

Reviewed-by: Maria Sfiraiala maria.sfiraiala@gmail.com

[RaduNichita]

It works for me as well.

I used something more hackish:

int main(void)
{
        struct stat st1, st2;
        int f = open("file", O_CREAT);
        fstat(f, &st1);
        close(f);

        f = open("file", O_RDONLY);
        stat("file", &st2);
        printf("Should be same: %ld %ld\n", st1.st_ino, st2.st_ino);
        close(f);
        return 0;
}

but it does the trick

Thanks, @andreittr

Reviewed-by: Radu Nichita radunichita99@gmail.com

[razvand]

Approved-by: Razvan Deaconescu razvand@unikraft.io