During runtime when a program asks for a memory block (say, by malloc()), its provided with a block of virtual addresses, say 0x10000000 to 0x1000A00 (for 32 bit). During the execution, other processes are incorporated into the main memory and pages 0x10000000-0x100000A0 are paged out. After some time, the program requests the page 0x10000000. Its incorporated back into the main memory (at the cost of some other page) but its assigned a new virtual address, but the program is oblivious of the new virtual address assigned to it and references the it using 0x10000000. How is this problem resolved ? Does it proceed in any other way ?

The application has a virtual address to begin with. so when the page is swaped into memory the os associates the phycial location the page is swapped into with the appropropriate virtual address. the app continues to access the virtual address it had from the begining and is completely oblivious of the swap/paging process.

This is basiclly a form of virtualization. The os present the memory resource ( physical and virtual) as a single storage resource.

Thanks, by I wanted to ask this:

Suppose the contents of page 0 are swapped out and are replaced by some other data, when the process references page 0 by the virtual address 0x00000000, it'll not be knowing that the original contents of page 0 have been swapped out. Since it uses virtual addresses (since virtual addresses don't disappear, how can the process know that its a page fault), how can it know that the value at that virtual address is the original one or has been replaced.

The userspace process neither knows nor cares about page fault. It references virtual addresses - if a fault occurs, the process is interrupted until the fault is resolved, then it is re-dispatched. As far as the process is concerned all the addresses it references are always (instantly) available - it doesn't even know it was interrupted.
Have a read of this

Thanks. All this time, by page I was understanding the pages in the virtual memory table, though the pages in the memory were meant.

So, I get these things :

1. Any process larger than 2GiB can't be accommodated since each process is given only 2GiB virtual addresses.

2. If the swap space as well as the main memory gets filled up, the kernel gives an error saying "Virtual memory is low" (Actually, shouldn't it say that "swap is too small" as virtual memory is infinite)

3. The reason swap space is maintained is that if a page fault occurs, the page is first located in the swap space as compared to searching the entire hard disk. If its not found there, then the remaining hard disk is checked. This checking, though occurs just for the first time when the process is being loaded, because otherwise, the only reason for the page to be not present in either the swap or the main memory is that it has ended or the process has been killed.

4. Even when a process swaps out of the memory, the page table for that process does keep some info about where that page is in the swap

5. I take it that "increasing virtual memory" is actually a misnomer because virtual memory is infinite. What is meant is increasing the swap space.

Am I right?

No. It keeps its original virtual address.

When the page is taken out of that process's resident set (prior to being physically swapped out) the kernel sets the page table entry for that virtual page of that process to fault. But that fault is handled later by the kernel, so the user code in the process doesn't know about it.

Depends on the OS, the architecture, and maybe the program.

2GiB is the default limit for 32 bit Windows. 3GiB is the default limit for 32 bit Linux. Each can be changed.

What OS does that? Some version of Windows?

Nonsense.

Swap space is maintained because there are "anonymous" pages, meaning pages that do not correspond directly to a properly sized and aligned chunk of some file.

When a page is out of physical memory, the page table data keeps track of where the page actually is (which part of which file or which slot in the swap file). There is no search and there is no checking one place then another. When it is time to load the page into memory, the kernel knows where to get it.

More nonsense. See above explanation.

Virtual memory is not infinite. There are several different related meanings of the phrase "virtual memory" but none of them are infinite and most of them can be increased up to some limit.

What's hard to understand about that? Windows defaults to increasing swap space automatically when it thinks it should (I always turn that feature off and select a good swap size myself). Linux does not increase swap space automatically, but the root user can increase swap space in various ways even on a running system.