Why is it a pity? To support relative paths, the concept of current
directory must also be maintained and this, like the concept of parent-child
process relationships, is not something that is relevant in KM. It is
always something that is properly implemented in the sub-system because the
behaviour must be sub-system dependent.

"Corinna Vinschen" wrote in message
news:git93m$r5a$1@perth.hirmke.de...

Do you have an alternative solution in mind? If so, what?

The blob size as I mentioned is variable. I would pick an upper bound that
way bigger than I can conceive anyone using and choose that as the size. It
allows very efficient indexing without wasting space. At least that's what I
gather from what I read about sparse files. Also, the NTFS change journal
uses sparse files so there must be some benefit, right?

What do you mean by persistency? Data will be persisted to the sparse file.
I will most likely have to age things, not based on a LRU scheme as that
would require me to keep some sort of LRU list which would complicate things.
I would probably just make the sparse file circular and pick an upper bound
of the index. When it wraps I would end up writing over the first blob.

This points out another thing I might have to do. Write the index into the
location so I can tell when data has been overwritten. If someone ask for
index x and at the slot for index x is written data for index y then I can
return an error. In this case index x modulus the size of the circular
buffer = index y modulus the circular buffer.
--
Thanks,
Nick

Hmmm, I replied to this yet it didn't seem to make it to this thread.

The indexing would look something similar to:

GetBlob(int index, byte *bytes, int size)
{
Seek(_sparse, (index + 1) * 1GB, SEEKOFFSET_ORIGIN);
Read(_sparse, &length, sizeof(length));
Read(_sparse, bytes, min(length, size));
}

Most likely I would use the first block to store information, like the next
free block. Other than that the indexing would be as showin above. Just
like indexing an array. That's the beauty of sparse files, right? You can
be wasteful and pick a huge block size and the OS will only consume the
actual amount of space you use. Of course the OS must have to do some book
keeping, but better the OS than me.

The NTFS change journal uses sparse file so I assume it saw a benefit in
using it.
--
Thanks,
Nick

Hi,

I plan to (possibly) utilize and employ alternate meta data for some
of our server files. Off hand, I'm thinking that it will help
consolidate some files that are currently coupled or associated by
file name and differ only by extension.

The key concept is that they must exist as a group, i.e. a missing
file is not expected in the design and considered a critical design or
logic or operation error or occurrence and manual repairs or cleanup
is required.

A rare occurrence, but there is one area where it there is a small
probability to happen, i.e, one of the files is not created or it is
not consistent with the rest.

So this is one area where I would like to consider alternate meta data
where one file is used with additional meta data files.

For example, right now, one of part of our storage framework where 4
files are used, the first three (triplets) are required, the 4th is a
processing history file of the triplet:

Hi All,
I developed NDIS IM driver. I install it under admin mode and work
fine under admin mode. But If I try to open same driver handle then
CreateFile gets failed and last error code is 2 i.e. "The system
cannot find the file specified. ".
Create Call is:
ANDLE hIoctl = CreateFileA(
"\\\\.\\CTSTNtFtr",
FILE_ALL_ACCESS,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
);
I tried with MAXIMUM_ALLOWED parameter but same result.
Please suggest me what should I do?
Regards,
Anand

I'd like to keep last DbgPrint messages in a ring buffer, so
that in case of bugcheck, it will be included in the dumps.
Kind of the "in-flight recorder" of KMDF, and similar to what does
the WinInternals DebugView and it's driver.

The target runs in no-debug mode, and due to some reasons,
using DebugView is not possible.

Should I roll my own driver to hook DebugService (or whatever)
or there's a simpler way?

Regards,

Do you have another solution in mind?

I indicated the blob sizes are variable and I can't pick a max. Well
actually I am picking a max, but that should be an unreasonably large value
that should be much larger than anyone needs. That's the beauty of using
sparse files, or so I gathered. There must be some reason why the OS chose
sparse files for the NTFS change journal.
--
Thanks,
Nick

nicknospamdu@community.nospam
remove "nospam" change community. to msn.com

"Alexander Grigoriev" wrote:

pseudo code:

long GetBlob(int index, byte *buffer, long bytes)
{
Seek(sparse, (index + 1) * 1GB);
Read(sparse, &length, sizeof(length));
return Read(sparse, buffer, min(bytes, length))
}

Otherwise if you don't use sparse files and put one blob right after the
next, then you either need to maintain an index in the file or you need to
read the list each time you want to retrieve a blob.

Most likely I'll use the first blob to store some info, like the next free
index.
--
Thanks,
Nick

nicknospamdu@community.nospam
remove "nospam" change community. to msn.com

"m" wrote:

Hi,

what is the advantage, better to say the usage scenario
for Fibers instead of Threads? I remember a Checkbox
in SQL Server 6 or 7 where you could choose in between
Threads and Fibers for the SQL Server Engine. I personally
never used Fibers before,...

What is a real-life usefull scenario for Fibers?

Regards

Kerem

--
-----------------------
Beste Grüsse / Best regards / Votre bien devoue
Kerem Gümrükcü
Microsoft Live Space: http://kerem-g.spaces.live.com/
Latest Open-Source Projects: http://entwicklung.junetz.de

Hello All,

Is there any way to inject a dll into an explorer process? I know one -
using the AppInit_DLLs registry value but I expect there is another one
that is more elegant.
It's necessary for me to send a window message to Explorer in Vista from
a nt service. The idea is to inject dll into Explorer, then it will
create a thread and in cycle will get from service some data (via some
interop. communication) and generate window messages.

Also perhaps shell extensions can help, but as I understand they are
delay loaded and for their loading some condition must occur (for
example if it's an icon handler extension then it will be loaded only
when a first file with such extension is started to show). Am I wrong
and some shell extension type can be suitable?

Any idea is appreciated. Thanks.