XV6: ptable initialization - c

Question

I'm talking about:
struct {
struct spinlock lock;
struct proc proc[NPROC];
} ptable;
which resides in proc.c file.
Can someone please explain where it is initialized?
Because, in proc.c I've never seen something (process) being added to it.
To be more precise, let's say I'm looking at the scheduler code:
void
scheduler(void)
{
struct proc *p;
for(;;){
// Enable interrupts on this processor.
sti();
// Loop over process table looking for process to run.
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p−>state != RUNNABLE)
continue;
// Switch to chosen process. It is the process’s job
// to release ptable.lock and then reacquire it
// before jumping back to us.
proc = p;
switchuvm(p);
p−>state = RUNNING;
swtch(&cpu−>scheduler, proc−>context);
switchkvm();
// Process is done running for now.
// It should have changed its p−>state before coming back.
proc = 0;
}
release(&ptable.lock);
}
}
In:
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
you can see that we are looping thorough each process in ptable. My question is, how did they get there?
Thanks!

Answer 1

It is initialised.
struct {
struct spinlock lock;
struct proc proc[NPROC];
} ptable;
the above code defines a struct (with no name) and initialises ptable as one struct of this type.
maybe you are confusing with this syntax:
struct ptable {
struct spinlock lock;
struct proc proc[NPROC];
};
here we are only defining a struct name ptable and there are no initialisations.

Answer 2

You won't find the initialization in xv6's code. Here's why.
C initializes proc's int and enum variables to 0. When ptable is implemented, struct proc proc[NPROC]; creates an array of 64 processes whose fields are initialized to 0 by the language. 0 happens to be the value of the UNUSED enumeration.
allocproc loops through ptable.proc looking for state=UNUSED, then initializes the first one it finds to all the needed values. So there's no need to explicitly initialize the structures in the array.

Answer 3

struct {
struct spinlock lock;
struct proc proc[NPROC];
}ptable;
It's allocated on the stack and initialized automatically. The trick here is that it's written in the GCC way, also called anonymous struct.

Answer 4

The struct ptable being a global variable was loaded into memory as a part of the bootmain() call during the booting of xv6 kernel. Since it is global, the default values are initialized.
Now coming to how they are actually used for storing processes and when the entries are modified.
The first process is created by userinit() which chooses an unused entry and uses it for setting up its own PCB.
After the hand crafted initproc is made by the kernel, the first call to scheduler happens which is what you are referring to here.
Since the scheduler will select a RUNNABLE process and the only one we have right now is the initproc itself, it is the one that starts running.
It makes a call to fork() for spawning a shell which calls allocproc() on each call to get another unused entry from ptable and allocate it to the process.
This is how the ptable is populated during fork and helps xv6 do a book keeping of the active processes.