Page fault occurs when the requested page is not present in memory. When a program is executing, it accesses memory locations to read or write data. These memory locations are divided into fixed-size blocks called pages. The operating system manages these pages and their corresponding physical memory locations through a data structure called a page table.

Here is a detailed explanation of when and why page faults occur:

1. Memory Management and Paging:
- Memory is divided into fixed-size blocks called pages, and the process address space is divided into logical pages.
- The operating system maintains a page table that maps logical pages to physical pages in memory.
- When a program accesses a memory location, the operating system uses the page table to translate the logical page number to a physical page number.
- If the requested page is not present in memory, a page fault occurs.

2. Page Fault Handling:
- When a page fault occurs, the operating system interrupts the program's execution and handles the fault.
- The operating system identifies the page that caused the fault and determines if the page is on disk or needs to be fetched from secondary storage.
- If the page is on disk, the operating system initiates a disk I/O operation to bring the page into memory.
- Once the page is loaded into memory, the page table is updated to reflect the new mapping between logical and physical pages.
- Finally, the program's execution is resumed from the point of interruption.

3. Causes of Page Faults:
- Page faults can occur due to various reasons such as:
a) Initial access: When a program starts execution, the pages it requires may not be in memory, leading to page faults.
b) Demand Paging: In demand-paged systems, not all pages are loaded into memory initially. As the program accesses new pages, page faults occur to bring them into memory.
c) Swapping: If the system is low on physical memory, pages may be swapped out to disk. When a swapped-out page is accessed, a page fault occurs to bring it back into memory.
d) Copy-on-Write: When multiple processes share the same pages, a page fault occurs if a process tries to modify a shared page. The operating system creates a private copy of the page for the process.

In conclusion, a page fault occurs when the requested page is not present in memory. The operating system handles the fault by fetching the page from disk or secondary storage and updating the page table. Page faults are an essential part of memory management in operating systems and play a crucial role in efficient memory utilization.