[Autogenerated] Our focus in this module is about the
generic management of object types, regardless of the actual type of object.
And the project Manager's job,
is to manage object in a generic way without being too
particular about the specific object type.
So every object, is built out of two pieces.
The first piece, is owned by the object manager.
And this is the object header this is the part that contains
specifics that are common to every object type,
and We'll see what those specifics.
Are in a moment.
The other part, is the specifics of the real object So what does it mean?
To be a process.
What does it mean?
To be a thread, or a job,
or a file or anything other than just the generic pieces.
And this part, is owned by the executive for some object types there.
Is also a kernel object internally,
which is owned by the kernel by the lower level of the entire thing.
That we know as the Windows kernel you might recall from previous course,
that We have the executive end the kernel as being the two layers there.
So an example for that would be a process,
project a process object, is fair complex,
and is managed by the structure called E process.
But the first member of the E process.
Is a K process structure which manages the perhaps
more internal part of the process.
So this thing exists for very specific types of objects,
namely processes, and threads, we know that threads,
are also managed by an thread, data structure,
and the K thread, is always the first member for most objects there.
Is no internal object there.
Its just that single structure such as the case for a job,
a job has a data structure called E job,
and this is it there, is no K job there,
is no such thing because a job object, is a fairly high level one.
And only being managed by the executive.
In any case, all these pieces,
are not really important for the object managers as far as the project manager,
is concerned.
So what do we have in the header first We have the object name.
Some objects can have names, object types can have names.
And If they do have a name, and this is where it's going.
To be stored, and As I mentioned, in the Beginning there's a hierarchy,
that is used by the object manager.
To store named objects,
and If this is the case if the object is in fact named it
might be in a certain directory object, which is another kind of kernel object,
and this is where it's actually stored.
And We'll see both of these things later on.
In this module there's a security descriptor,
that allows us to protect the kernel object,
to indicate who can do what with the object?
So, security descriptor, is a generic thing,
and any kernel object,
can be protected using this entity called the security
descriptor which we dig into in the Future.
Of course, there's a management there about the number of handles.
That are open, to the object, and the number of pointers,
that are open, to the object, that are kind of held by kernel components,
to the object,
and we know that these two combined represent the
reference count of the object in general.
Technically its referred in the kernel sometimes as a pointer count,
which includes the references coming from kernel clients,
holding onto pointers, to the object,
and actual handles being held by user mode or kernel mode clients,
and only When that reference count drops.
To zero, only then will the object actually, be destroyed by the object manager.
And then There's the object type, the object type,
is a pointer, to a type object.
You can think of that from a perspective of object
orientation as having objects pointing,
to the type or the class that represents what does it mean?
To be this kind of thing.
So all the process objects, in the system point,
to the same type object representing what does it mean.
To be a process.
So, a type object, is a single ton pair object type.
That's one of those for each object type and The type object itself also
has some properties such as the total number of handles.
And objects for this kind of object type.
In fact, that's the thing we've seen.
In the previous demo, in the object types view in in the object explorer tool,
we can also see the there, the type name,
which just means the name of the type such as process or job or thread,
and So on synchronize, able means whether that all kind of object type.
Is OK, to use with weighting functions such as wait for single object,
which we'll see later in this course, we also have the pool type,
which indicates whether objects of these types should be allocated
from non page pool which is a kind of memory.
That never is is never paged out or the normal page
pull which is like stand out memory, which can be paged out if needed.
In fact, you might have noticed that kind of of column,
in the object types of view in object explorer,
and there's also object methods.
You can see Think of that as like future functions.
In the sense,
that have some special handling for certain cases when certain operations.
Are happening on objects.
And this is all being set up when the object type,
is being initialized,
we can see many of these properties using the kernel
debugger which is what we'll do Next.