7

We create a file for use as memorymappedfile.

we open with GENERIC_READ | GENERIC_WRITE
we use share with FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
we use file attributes FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE

we create the file successfully. We can reopen it as many times with the same flags as we want.

Once one handle has been closed, we can no longer open any more handles, it returns with ERROR_ACCESS_DENIED. We can cause this by closing any of the handles, either the first from CreateFile(ALWAYS_CREATE), or the others from CreateFile(OPEN_EXISTING).

Is there any way to avoid this ? We use the memoryMappedFile as communication between the different processes that must share resources. these processes sometimes start and stop. Right now as soon as we close one handle, we are stuck unable to open the memorymappedfile.

I have tried changing the open calls to use FILE_ATTRIBUTE_NORMAL, so only the create call uses CLOSE_ON_DELETE but that has no effect on this situation.

Improve this question
2
  • 1
    your processes should coordinate and only the "master" should use the delete_on_close flag, the master being the first to start up and the last to shut down. Commented Apr 13, 2015 at 21:36
  • 1
    You are focusing on the wrong problem. Yes, it is very difficult to deal with a process dying unexpectedly in this kind of scenario. Many more things go wrong beyond a file that doesn't get deleted, a deadlock is traditional. You often need a guard process that doesn't do anything else but ensure that everybody co-operates and cleans up when they don't. That file that doesn't get deleted is the least of the problem, you'll get it the next time. Commented Apr 13, 2015 at 23:09

2 Answers 2

Reset to default
10

The problem you're running into is that once a file handle opened with FILE_FLAG_DELETE_ON_CLOSE is closed, the operating system will no longer allow new handles to be created.

The gory details: When processing an IRP_MJ_CLEANUP (which is what happens win a handle is closed) for a file opened for delete-on-close, Windows file systems will set an internal flag on the file object indicating that it's on it's way out. Subsequent open attempts on the file will be failed with STATUS_DELETE_PENDING, which the Win32 subsystem will map to the Win32 ERROR_ACCESS_DENIED code you're seeing.

For your use case, you might want to consider using the Named Shared Memory (MSDN) pattern. Basically, let the operating system manage the space for your shared memory. Just make sure you apply the appropriate security attributes, and you're good to go.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thank you for the clarity. I figured as much from what I'd observed from the usermode side. Trying the delete on close flag was a recent addition to circumvent users having to add handling to their scripts. It was for the rare case when something crashes and doesn't get cleaned up properly. I will look into using the pagefile as an alternative backing store for the memory mapped sections. Gory details much appreciated and understood.
0

It turns out the venerable Raymond Chen replied to this on his Microsoft devblog, The Old New Thing. Bukes is correct but as an alternative, as Raymond says in his article:

It looks like they really want the file to remain valid (including allowing further Create­File calls to succeed) for as long as any open handle continues to refer to the file. Fortunately, the customer needed the handle only to create a memory-mapped view. The file pointer was not important. Therefore, the customer could use Duplicate­Handle instead of Create­File to get additional handles to the file. Since all of the handles refer to the same file object, the file object will not delete the file until all of the handles are closed.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.