Kernel thread scheduling

[ruben@mrbrklyn.com (Ruben Safir)]

On 04/12/2015 12:16 AM, nick wrote:
> This finds the next node in the red black tree for  sched_enities.
> Basically rb_next finds the next node in the tree. The argument is 
> the rb_node structure embedded in the structure using a red black
> tree.


The problem is this


struct mystruc {
	int a;
	char * string;
} wonderful;

char * string2 = wonderful.string;



There is no way to know that string2 comes from wonderful.
That is the problem I have with the nodes

The node is an instance of sched_entity.  But unless there is a field
that says what task_entity it is embedded in, in of itself, there is no
way to know.  There is no 'this' C.

Obviously if does know.  I'll look at chapter 6

I'm also looking at this



static struct sched_entity *__pick_next_entity(struct sched_entity *se)
{
	struct rb_node *next = rb_next(&se->run_node);

	if (!next)
		return NULL;

	return rb_entry(next, struct sched_entity, run_node); <<==macro
}



The macro is:  I think:
http://lxr.free-electrons.com/source/include/linux/rbtree.h#L50

50 #define rb_entry(ptr, type, member) container_of(ptr, type, member)

container_of is
http://lxr.free-electrons.com/source/include/linux/kernel.h#L798


791 /**
792  * container_of - cast a member of a structure out to the containing
structure
793  * @ptr:        the pointer to the member.
794  * @type:       the type of the container struct this is embedded in.
795  * @member:     the name of the member within the struct.
796  *
797  */
798 #define container_of(ptr, type, member) ({                      \
799         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
800         (type *)( (char *)__mptr - offsetof(type,member) );})


Now I have embedded macros which I thought you couldn't even do...

In trying to understand this I stumbled on

http://linuxkernel51.blogspot.com/2011/02/how-containerof-macro-works-example.html
 How "container_of" macro works, & an Example
Here iam giving a small code snippet that gives and idea about working
of "container_of", this posed me little difficulty in understanding,
after google-ing i got some examples and after working on that i wrote a
simple C application that depicts its working. here i have defined two
macros "offsetof" and "container_of" which i have extracted from
"kernel.h" header.
       Please interpret this code and try some trick to understand
"container_of".

container_of macro is defined in linux/kernel.h

syntax: container_of( pointer, container_type, container_field );

This macro takes a pointer to a filed name container_field, within a
structure of type container_type, and returns a pointer to the
containing structure .

simply this is a convenience macro that may be used to obtain a pointer
to a structure from a pointer to some other structure contained with in it.


Code :

#include <stdio.h>
#include <stdlib.h>

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

#define container_of(ptr, type, member) ({            \
 const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 (type *)( (char *)__mptr - offsetof(type,member) );})

struct test1 {
 int a;
};

struct test2 {
 int b;
 struct test1 z;
 int c;
};

int main()
{
 /* existing structure */
 struct test2 *obj;
 obj = malloc(sizeof(struct test2));
 if(obj == NULL){
       printf("Error: Memory not allocated...!\n");
 }
 obj->z.a = 51;
 obj->b = 43;
 obj->c = 53;

 /* pointer to existing entry */
 struct test1 *obj1 = &obj->z; //both of type test1

 struct test2 *obj2 = container_of(obj1, struct test2, z);

 printf("obj2->b = %d\n", obj2->b); ///notsure what this does,need a nap

 return EXIT_SUCCESS;
}