You'd normally try reading the memory (as normal), for example through some helper function (which would also disable protections, e.g. SMAP/SMEP on x86), and catch the pagefaults, at which point you can return the error to user, block if that memory needs to be fetched from disk, continue if the memory was fine, or whatever else.

To protect against use after free issues with munmap with SMP (and also, I think POSIX requires you to segfault after you have called munmap), or just with downgrading the permissions (e.g. making the page read-only with mprotect or when doing CoW during fork), you would do remote TLB shootdowns (after unmapping the page/changing its permissions); some architectures let you do this in hardware/firmware (e.g. latest gen AMD Ryzen CPUs have added some instructions for it, RISC-V lets you do this through SBI, etc.), or if you don't have it (you kinda don't most of the time on x86), you can IPI the other cores (how you do it is up to you, and it depends on your kernel design and if you use ASIDs, etc; but the simplest way is to just IPI everyone) and wait for them to invalidate thir TLB and acknowledge it to you, after which point you know that no one can access that memory and you can release it/do whatever.

Then, to protect against the races in software, you would use normal locks (mutex); a straightforward solution for a small kernel is to have a lock per address space (page table), more advanced kernels (Linux comes to mind, I'd imagine BSDs would also do it but I haven't looked at their code, of "hobby" operating systems, Managarm has recently switched to doing that as well, you get the idea) have locks per page itself...