There is nothing impossible COW for mapped files, but it is not a good match for the
expected usage model for DAX.
The idea is that programs can mmap files and the build interesting data structures in
them, just like they do in DRAM. This means lots of small updatEs, and that would be very
slow if each of them required a COW.
The reason we use COW for normal accesses is to provide atomicity. Programs will probably
want doe form of atomicity for their mmaped data structures, but part of the DAX bargain
is that programmer are responsible for this rather than the FS.
Composed on (and maybe dictated to) my phone.
On Aug 4, 2017, at 08:09, Bart Van Assche
> On Thu, 2017-08-03 at 00:48 -0700, Steven Swanson wrote:
> +### DAX Support
> +Supporting DAX efficiently is a core feature of NOVA and one of the challenges
> +in designing NOVA is reconciling DAX support which aims to avoid file system
> +intervention when file data changes, and other features that require such
> +NOVA's philosophy with respect to DAX is that when a program uses DAX mmap to
> +to modify a file, the program must take full responsibility for that data and
> +NOVA must ensure that the memory will behave as expected. At other times, the
> +file system provides protection. This approach has several implications:
> +1. Implementing `msync()` in user space works fine.
> +2. While a file is mmap'd, it is not protected by NOVA's RAID-style parity
> +mechanism, because protecting it would be too expensive. When the file is
> +unmapped and/or during file system recovery, protection is restored.
> +3. The snapshot mechanism must be careful about the order in which in adds
> +pages to the file's snapshot image.
Thank you for having shared this very interesting work. After having read the
NOVA paper and patch 01/16 I have a question for you. Does the above mean that
COW is disabled for writable mmap-ed files? If so, what is the reason behind
this? Is there a fundamental issue that does not allow to implement COW for
writable mmap-ed files? Or have you perhaps tried to implement this and was the
performance not sufficient? Please note that I'm neither a filesystem nor a
persistent memory expert.