Hello linux-block, We are experiencing data corruption in our storage intensive server application and are wondering about the semantics of "racy" O_DIRECT writes. Normally we target XFS, but the question is a general one. Specifically, imagine that we are writing a single 4K aligned page, with contents AB00 (each char being 1K bytes). We only care about the first 2048 bytes (the AB part). We are using libaio writes (io_submit) with O_DIRECT semantics. While the write is in flight, i.e., after we have submitted it and before we reap it in io_getevents, the userspace application writes into second half of the page, changing it to ABCD (let's say via memcpy). The first half is not changed. The question then is: is this safe in the sense that would result in ABxx being written where xx "is don't care"? Or could it do something crazier, like cause later writes to be ignored (e.g. if something in the kernel storage layer hashes the page for some purpose and this hash is out of sync with the page at the time it was captured, or something like that). Of course, the easy answer is "don't do that", but I still want to know what happens if we do. Travis
