OpenVZ Virtuozzo Containers Wiki - User contributions [en]

User:Xemul

2015-09-03T13:07:59Z

Xemul: add photo

Биография: Архитектор в команде Odin Server Virtualization, идейный вдохновитель проекта CRIU. В компании Parallels с 2004 года, начинал в группе разработки ядра Linux, которую затем возглавил. Сейчас занимается архитектурными вопросами в команде серверной виртуализации.

Bio: Architect in Odin Server Virtualization team, creator and maintainer of the CRIU project. Joined Parallels in 2004 as junior Linux kernel developer, later became kernel team leader. Now works on architecture of the Odin Server products.

[[Image:Xemul.jpg|left|80px]]

File:Xemul.jpg

2015-09-03T13:07:45Z

Xemul:

User:Xemul

2015-09-03T13:06:53Z

Xemul: Created page with "Биография: Архитектор в команде Odin Server Virtualization, идейный вдохновитель проекта CRIU. В компании Paralle..."

LibCT

2014-05-14T21:18:21Z

Xemul: + two more backends

== Requirements ==
* C/C++ bindings (for Parallels SDK)
* Python bindings (for OpenStack)
** Might make sence to write Python code that just goes via RPC
* Fine grained support for namespaces and cgroups
* Extendable support for different private FS
* Extendable support for different NICs
* Support for external bind mounts
* Ability to enter a CT
* Ability to configure running CT
* Integration with CRIU for checkpointing
* Integration with CRIU for migration
* Ability to operate on remote host
* Ability to be used by non-root App
* Ability to resurrect after sudden App crash
* Ability to work on OpenVZ kernel (backend)
* Ability to run libct supporting tools on older (OpenVZ) kernels (depends on above)
* Integration with Docker libcontainer to give any container system implementing the ability to deploy docker packages
* Backend for Solaris Zones and probably Virtuozzo Windows Containers

LibCT

2014-05-14T21:08:09Z

Xemul: Idea how to do python

LibCT

2014-05-14T21:07:42Z

Xemul: Created and filled Parallels reqs

== Requirements ==
* C/C++ bindings (for Parallels SDK)
* Python bindings (for OpenStack)
* Fine grained support for namespaces and cgroups
* Extendable support for different private FS
* Extendable support for different NICs
* Support for external bind mounts
* Ability to enter a CT
* Ability to configure running CT
* Integration with CRIU for checkpointing
* Integration with CRIU for migration
* Ability to operate on remote host
* Ability to be used by non-root App
* Ability to resurrect after sudden App crash
* Ability to work on OpenVZ kernel (backend)
* Ability to run libct supporting tools on older (OpenVZ) kernels (depends on above)
* Integration with Docker libcontainer to give any container system implementing the ability to deploy docker packages

Ubstat system call

2010-02-08T09:08:53Z

Xemul: Fixed contents structure... again :\

This article describes an interesting system call which was designed to pick beancounters statistics.

== Overview ==
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

== How it works ==
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

== API ==
The system call description is

<source lang="c">
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</source>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

=== Arguments description ===

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

=== The statistics format ===
The format of data returned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<source lang="c">
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</source>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<source lang="c">
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</source>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<source lang="c">
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</source>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<source lang="c">
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</source>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

=== Notification ===
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<source lang="c">
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</source>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

=== Return value ===
The system call returns -1 in case error has occurred. In case of <code>UBSTAT_UBPARMNUM</code> it returns <code>UB_RESOURCES</code> and in all other cases it returns the amount of bytes written to the <code>buf</code>.

== Demo ==
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea and will only work on x86_64.
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</source>

== Implementation constraints ==
Unfortunately the API is not architecture independent and thus 32-bit application will simply not work on x86_64.

[[Category:UBC]]

Ubstat system call

2010-02-05T14:20:48Z

Xemul: Added the "return value" section

This article describes an interesting system call which was designed to pick beancounters statistics.

= Overview =
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

= How it works =
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

= API =
The system call description is

<pre>
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</pre>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

== Arguments description ==

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

== The statistics format ==
The format of data rerurned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</pre>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</pre>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</pre>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<pre>
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</pre>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

== Notification ==
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<pre>
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</pre>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

== Return value ==
The system call returns -1 in case error has occurred. In case of <code>UBSTAT_UBPARMNUM</code it returns <code>UB_RESOURCES</code> and in all other cases it returns the amount of bytes written to the <code>buf</code>.

= Demo =
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea and will only work on x86_64.
<pre>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</pre>

= Implementation constraints =
Unfortunately the API is not architecture independent and thus 32-bit application will simply not work on x86_64.

[[Category:UBC]]

Ubstat system call

2010-02-05T14:16:25Z

Xemul: Added more information about arch

This article describes an interesting system call which was designed to pick beancounters statistics.

= Overview =
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

= How it works =
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

= API =
The system call description is

<pre>
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</pre>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

== Arguments description ==

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

== The statistics format ==
The format of data rerurned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</pre>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</pre>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</pre>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<pre>
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</pre>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

== Notification ==
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<pre>
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</pre>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

= Demo =
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea and will only work on x86_64.
<pre>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</pre>

= Implementation constraints =
Unfortunately the API is not architecture independent and thus 32-bit application will simply not work on x86_64.

[[Category:UBC]]

Ubstat system call

2010-02-05T14:15:03Z

Xemul: Fixed Demo arch

This article describes an interesting system call which was designed to pick beancounters statistics.

= Overview =
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

= How it works =
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

= API =
The system call description is

<pre>
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</pre>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

== Arguments description ==

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

== The statistics format ==
The format of data rerurned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</pre>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</pre>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</pre>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<pre>
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</pre>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

== Notification ==
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<pre>
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</pre>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

= Demo =
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea and will only work on x86_64.
<pre>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</pre>

[[Category:UBC]]

Ubstat system call

2010-02-05T14:13:09Z

Xemul: Gategorized

This article describes an interesting system call which was designed to pick beancounters statistics.

= Overview =
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

= How it works =
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

= API =
The system call description is

<pre>
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</pre>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

== Arguments description ==

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

== The statistics format ==
The format of data rerurned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</pre>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</pre>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</pre>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<pre>
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</pre>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

== Notification ==
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<pre>
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</pre>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

= Demo =
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea.
<pre>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</pre>

[[Category:UBC]]

Ubstat system call

2010-02-05T14:12:47Z

Xemul: Initial page

This article describes an interesting system call which was designed to pick beancounters statistics.

= Overview =
The system call appeared in the very first version of the OpenVZ. Its API is rather sloppy, but this is something we have to live with due to backward compatibility reasons.

The main intention of this system call is to allow a user space process get the beancounters statistics ''periodically''. This statistics includes the fields observed in the <code>/proc/user_beancounters</code> file and one more field - the so called <code>minheld</code> value which is opposite to the <code>maxheld</code> one. As long as exporting the statistics the system call also notifies the task about the desired period has elapsed. The notification is performed by sending a signal to a process and this notification is one-shot.

= How it works =
The typical usage of this call is in performing the following steps.
# Request the amount of resources
# Get the IDs of all the living beancounters
# Setup a handler for some signal (e.g. USR1)
# Perform a system call to setup the notification
# Go do something (or sleep for ever)

In a signal handler one should just perform a respective system call to get the stats and schedule the next notification (yes, they are performed in one go; see below for more details).

= API =
The system call description is

<pre>
long ubstat(int func, unsigned long luid, void *notif, void *buf, int size);
</pre>

The macros and data typed used are declared in <code>include/ub/ub_stat.h</code> file.

== Arguments description ==

'''<code>func</code>''' is like <code>cmd</code> in the <code>ioctl</code> system call. It can be one of
* <code>UBSTAT_READ_ONE</code> to read basic stats for one resource. The desired resource itself should be <code>or</code>-ed with the <code>func</code>
* <code>UBSTAT_READ_ALL</code> to read basic stats about all the resources
* <code>UBSTAT_READ_FULL</code> to read extended stats about all the resources
* <code>UBSTAT_UBLIST</code> to get the ids of the beancounters
* <code>UBSTAT_UBPARMNUM</code> to get the number of resources used by the kernel
* <code>UBSTAT_GETTIME</code>

See below for what ''basic'' and ''extended'' stats mean.

'''<code>luid</code>''' is the desired beancounter ID. Only one beancounter can be checked at one call.

'''<code>notif</code>''' is the pointer to a <code>ubnotifrq_t</code> structure which describes the notification details (see below).

'''<code>buf</code>''' is the pointer to a chunk of memory, which will contain the data requested.

'''<code>size</code>''' is the <code>buf</code> memory size.

== The statistics format ==
The format of data rerurned into the buffer depends on the function requested.

'''1. <code>UBSTAT_READ_ONE</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
}
</pre>

It contains the time period for which the stats are returned and the <code>maxheld</code> and <code>failcnt</code> for the resource.

'''2. <code>UBSTAT_READ_ALL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long maxheld;
unsigned long failcnt;
} ubstatparm_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
}
</pre>

It contains the same info as the <code>UBSTAT_READ_ONE</code> does, but for all the resources.

'''3. <code>UBSTAT_READ_FULL</code>''' format is
<pre>
typedef unsigned long ubstattime_t;

typedef struct {
unsigned long barrier;
unsigned long limit;
unsigned long held;
unsigned long maxheld;
unsigned long minheld;
unsigned long failcnt;
unsigned long __unused1;
unsigned long __unused2;
} ubstatparmf_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
}
</pre>

It contains the extended info for all the resources.

'''4. UBSTAT_UBLIST''' treats the <code>buf</code> to point to the <code>unsigned long</code> array.

'''5. UBSTAT_UBPARMNUM''' ignores the <code>buf</code>.

'''6. UBSTAT_GETTIME''' format is
<pre>
typedef unsigned long ubstattime_t;

struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstattime_t cur_time;
};
</pre>

It returns the time interval within which the stats are collected and the current time.

All the times used are in seconds.

== Notification ==
The notification info is passed via the <code>notif</code> argument and is being set up for all the functions except the <code>UBLIST</code> and the <code>UBPARNUM</code>. The notification is one-shot, but note that once you requested the statistics the next shot is scheduled at the same time.

The <code>notif</code> should point to
<pre>
typedef struct {
long maxinterval;
int signum;
} ubnotifrq_t;
</pre>

The <code>maxinterval</code> is the time after which the notification will be delivered. It should be more than 1 (second).

The <code>signum</code> is the signal that will be sent to notify.

= Demo =
The following program demonstrates how you can (but not should) use the described API. This example is deliberately made very stupid and simple to demonstrate the main idea.
<pre>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ub_stat.h>
#include <signal.h>

#define UBSTAT_BUFSIZE 4096
#define UBSTAT_NOTIFSIG SIGUSR1
#define UB_RESOURCES 24

static char ubstat_buf[UBSTAT_BUFSIZE];
static int luid, func;
static ubnotifrq_t notif;
static void (*print_stat)(void *buf);

#define sys_ubstat(args...) syscall(503, ## args)

static void usage(void)
{
printf("ubstat <id> <period> <resource>\n");
printf("resource can be either num or:\n");
printf("-1 for all maxheld and failcnt\n");
printf("-2 for all at all\n");
}

static void print_stat_one(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[1];
} *data;

data = buf;

printf("maxheld: %lu\n", data->param[0].maxheld);
printf("failcnt: %lu\n", data->param[0].failcnt);
}

static void print_stat_all(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparm_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("\tmaxheld: %lu\n", data->param[res].maxheld);
printf("\tfailcnt: %lu\n", data->param[res].failcnt);
}
}

static void print_stat_full(void *buf)
{
struct {
ubstattime_t start_time;
ubstattime_t end_time;
ubstatparmf_t param[UB_RESOURCES];
} *data;
int res;

data = buf;
for (res = 0; res < UB_RESOURCES; res++) {
printf("res %d\n", res);
printf("minheld: %lu\n", data->param[res].minheld);
printf("maxheld: %lu\n", data->param[res].maxheld);
printf("failcnt: %lu\n", data->param[res].failcnt);
}
}

static inline int res2func(int resource)
{
if (resource >= 0) {
print_stat = print_stat_one;
return UBSTAT_READ_ONE | resource;
}
if (resource == -1) {
print_stat = print_stat_all;
return UBSTAT_READ_ALL;
}
if (resource == -2) {
print_stat = print_stat_full;
return UBSTAT_READ_FULL;
}

printf("Bad resource %d\n", resource);
exit(1);
}

static void do_notify(int x)
{
int err;

err = sys_ubstat(func, luid, (unsigned long)&notif,
ubstat_buf, UBSTAT_BUFSIZE);
if (err < 0) {
perror("Can't set stat");
exit(0);
}

print_stat(ubstat_buf);
}

static int do_ubstat(int id, int period, int resource)
{
luid = id;
func = res2func(resource);
notif.maxinterval = period;
notif.signum = UBSTAT_NOTIFSIG;
signal(UBSTAT_NOTIFSIG, do_notify);
do_notify(0);
}

int main(int argc, char **argv)
{
int id, period, res;

if (argc == 1) {
usage();
return 0;
}

id = atoi(argv[1]);
period = atoi(argv[2]);
res = atoi(argv[3]);

do_ubstat(id, period, res);

while (1)
sleep(10);

return 0;
}
</pre>

UBC auxiliary parameters

2008-10-01T16:39:42Z

Xemul: added comment about numfile barrier

{{UBC toc}}

Configuration of primary and secondary resource control parameters is
important for security and stability of the whole system. Auxiliary
parameters differ much from primary and secondary parameters in this respect.

== Introduction ==

The primary functions of auxiliary parameters are the following.
<ul>
<li>These parameters improve application's handling of errors and resource
consumption limitations.

Without these auxiliary parameters, possible bugs in applications (such
as forgetting to unlock locked files or forgetting to collect signals) will
cause slowdown and, after some time, killing of the applications because
of memory exhaustion. In presence of these parameters, applications
will notice the problem (because, for example, attempts to create new
file locks start to fail) and show an appropriate message helping to
debug the problem.

Another example. Each object such as opened file or established network
connection consume certain resources. When the container
is close to exhaustion of the resources allowed to him, it is
usually better to refuse creation of new object than to allow it but deny
memory allocation or terminate (in case of complete exhaustion of the
resources) an already running application.
</li>

<li>
These parameters improve fault isolation between applications in the
same container. Failures or misbehavior of one application
inside a container is more likely to cause hitting a
limit on some auxiliary parameter and normal termination of this mis-
behaving application, rather than abnormal termination of some other
long-running application inside the same container.
</li>

<li>
These parameters may be used to impose some administrative limits
on the container (for example, to not allow the user to run
database servers by limiting the amount of [[shmpages]], or limiting the
number of simultaneous shell sessions through [[numpty]]).
</li>
</ul>

So, auxiliary parameters play a role similar to limits imposed by
<code>setrlimit(2)</code> interface and limits configurable by
<code>sysctl(8)</code> in standard
Linux installations.

Because of this helper role in resource control, system management software
may show auxiliary parameters only in advanced mode for experienced
administrators and hide them in “basic” management modes.

== lockedpages ==
Process pages not allowed to be swapped out (pages locked by <code>mlock(2)</code>).

The size of these pages is also accounted into <code>[[kmemsize]]</code>.
The <code>barrier</code> may be set equal to the <code>limit</code> or may allow
some gap between the <code>barrier</code> and the <code>limit</code>, depending
on the nature of applications using memory locking features.

Note that typical server applications like Web, FTP, mail servers
do not use memory locking features.

The configuration of this parameter doesn't affect security and
stability of the whole system or isolation between containers.
Its configuration affects functionality and resource shortage reaction
of applications in the given container only.

== shmpages ==
The total size of shared memory (IPC, shared anonymous mappings and
<code>tmpfs</code> objects).

These pages are also accounted into <code>[[privvmpages]]</code>.

The <code>barrier</code> should be set equal to the <code>limit</code>.
The configuration of this parameter doesn't affect security and
stability of the whole system or isolation between containers.
Its configuration affects functionality and resource shortage reaction
of applications in the given container only.

== physpages ==
Total number of RAM pages used by processes in this container.

For memory pages used by several different containers (mappings of
shared libraries, for example), only a fraction of a page is charged to each
container.
The sum of the <code>physpages</code> usage for all containers
corresponds to the total number of pages used in the system by all
containers.

<code>Physpages</code> is an accounting-only parameter currently.
In future OpenVZ releases, this parameter will allow to provide guaranteed
amount of application memory, residing in RAM and not swappable.
For compatibility with future versions, the <code>barrier</code> of this
parameter should be set to <code>0</code> and the <code>limit</code> to
the maximal allowed value ([[MAX_ULONG]]).

== numfile ==
Number of open files.

The <code>barrier</code> should be set equal to the <code>limit</code>.
The configuration of this parameter doesn't affect security and
stability of the whole system or isolation between containers.
Its configuration affects functionality and resource shortage reaction
of applications in the given container only.

Note: actually currently adjusting the <code>barrier</code> will change the kernel behaviour on "pre-charging" the numfile resource. If you change one you will most likely not notice any changes in container behaviour at all. This ability was added for researching purposes purely.

== numflock ==
Number of file locks.

The configuration of this parameter should have a
gap between the <code>barrier</code> and the <code>limit</code>, as illustrated in
[[UBC configuration examples]].

Very high limits on <code>numflock</code> parameters and the big number
of file locks in the system may cause certain slowdown of
the whole system (but not fatal).
So, the limits on this parameter should be reasonable, depending
on the real requirements of the applications.

== numpty ==
Number of pseudo-terminals.

This parameter is usually used to limit the number of simultaneous shell
sessions.
The <code>barrier</code> should be set equal to the <code>limit</code>.
The configuration of this parameter doesn't affect security and
stability of the whole system or isolation between containers.
Its configuration affects functionality and resource shortage reaction
of applications in the given container only.
However, in OpenVZ systems, the actual number of pseudo-terminals allowed
for one container is limited to <code>256</code>.

== numsiginfo ==
Number of <code>siginfo</code> structures.

The size of the structure is also accounted into <code>[[kmemsize]]</code>.
The default installations of stand-alone Linux systems limit this number
to <code>1024</code> for the whole system.
In OpenVZ installations, <code>numsiginfo</code> limit applies to each
container individually.

The <code>barrier</code> should be set equal to the <code>limit</code>.
Very high settings of the <code>limit</code> of this parameter may reduce
responsiveness of the system.
It is unlikely that any container will need the limit greater than
the Linux default — <code>1024</code>.

== dcachesize ==
The total size of <code>dentry</code> and <code>inode</code> structures locked in memory.

<code>Dcachesize</code> parameter controls filesystem-related caches, such as
directory entry (<code>dentry</code>) and inode caches.
The value accounted into <code>dcachesize</code> is also included into
<code>[[kmemsize]]</code>.

<code>Dcachesize</code> exists as a separate parameter to impose a limit causing
file operations to sense memory shortage and return an error to applications,
protecting from memory shortages during critical operations that shouldn't
fail.

The configuration of this parameter should have a
gap between the <code>barrier</code> and the <code>limit</code>, as illustrated in
[[UBC configuration examples]].
The configuration of this parameter doesn't affect security and
stability of the whole system or isolation between containers.
Its configuration affects functionality and resource shortage reaction
of applications in the given container only.

== numiptent ==
The number of NETFILTER (IP packet filtering) entries.

The <code>barrier</code> should be set equal to the <code>limit</code>.
There is a restriction on the total number of <code>numiptent</code>.
It depends on the amount of other allocations in so called “vmalloc”
memory area and constitutes about <code>250000</code> entries.
Violation of this restriction may cause failures of operations with
IP packet filter tables (execution of <code>iptables(8)</code>)
in any container or the host system,
or failures of container starts.
Also, large <code>numiptent</code> cause considerable slowdown of processing
of network packets. It is not recommended to allow containers
to create more than 200–300 <code>numiptent</code>.

Kernel debug options

2008-09-01T13:40:32Z

Xemul: categorized

This page describes some debugging, that can be turned on in order to find more info about an oops/bug/deadlock/etc

== Memory debugging options ==
There are two sets of options, depending on what kind of memory allocator you use

=== SLAB ===
If you have a
<pre>
CONFIG_SLAB=y
# CONFIG_SLUB is not set
</pre>
disposition in your config file, then the proper debugging options are
<pre>
CONFIG_DEBUG_KERNEL=y
CONFIG_DEBUG_SLAB=y
CONFIG_DEBUG_SLAB_LEAK=y
</pre>

=== SLUB ===
If you have a
<pre>
# CONFIG_SLAB is not set
CONFIG_SLUB=y
</pre>
set of options, then your choice should be
<pre>
CONFIG_SLUB_DEBUG=y
CONFIG_SLUB_DEBUG_ON=y
</pre>

== Locking debugging ==
The following options are useful when debugging various deadlocks and memory corruptions. They produce some performance loss, however.
<pre>
CONFIG_DEBUG_SPINLOCK=y
CONFIG_DEBUG_MUTEXES=y
CONFIG_DEBUG_LOCK_ALLOC=y
CONFIG_DEBUG_SPINLOCK_SLEEP=y
CONFIG_DEBUG_LIST=y
</pre>

There are some others, but the above are minimal set.

[[Category:Kernel]]

Kernel debug options

2008-09-01T13:40:10Z

Xemul: New page: This page describes some debugging, that can be turned on in order to find more info about an oops/bug/deadlock/etc == Memory debugging options == There are two sets of options, depending...

Disassembling the kernel

2008-08-22T10:36:30Z

Xemul: Created

This page describes how to obtain sufficient disassembling of your kernel when reporting a new BUG caught on a self-compiled kernel.

== The <code>objdump</code> utility ==

The main utility used to do it is the <code>objdump</code> one. Most of the time it's enough just to run
<pre>
# objdump -dr <the-binary-file-to-dump> > <the-output-file>
</pre>
and the disassembled binary will be obtained.

Most often you'd need to provide the dump of the <code>vmlinu'''x'''</code> file like this:
<pre>
# objdump -dr vmlinux-<kernel-version> > vmlinux.decoded
</pre>

We'll need the <code>vmlinux.decoded</code> file in this case.

== Some hints that can be get from the kernel BUG report ==

Let's look at how a BUG report can look (in the <code>dmesg</code> output)
<pre>
BUG: unable to handle kernel NULL pointer dereference at virtual address 00000044
printing eip:
c05d575b
*pde = 00000000
Oops: 0000 [#1]
SMP
Modules linked in: ...
...
Call Trace:
[<c0429ea3>] local_bh_enable+0x95/0xa4
...
[<c05bc1ba>] net_rx_action+0x8f/0x185
[<c05b1aa9>] kernel_sendmsg+0x2f/0x3d
[<d0a7e24f>] xs_send_kvec+0x92/0x9a [sunrpc]
[<c048e3bc>] destroy_inode+0x24/0x33
[<d0a7e38e>] xs_sendpages+0x82/0x128 [sunrpc]
...
[<d0a80732>] rpc_async_schedule+0x0/0x8 [sunrpc]
[<c0433d6a>] run_workqueue+0x78/0xf5
[<c0433de7>] worker_thread+0x0/0xdc
...
[<c04371fb>] kthread+0x0/0x55
[<c0405913>] kernel_thread_helper+0x7/0x10
=======================
...
EIP: [<c05d575b>] ip_route_output_slow+0x40/0x6fa SS:ESP 0068:cf73bbbc
</pre>

I've thrown away some unneeded info, so as you can see some function names in the stack trace are accompanied with the <code>[sunrpc]</code> string. This is a module name, in you traces you can see some other modules. So, when you disassembled the <code>vmlinux</code> file and attached this to the BUG report, very likely we'll ask you to disassemble the modules, that are seen in the stack trace, so you'd have to run the
<pre>
# objdump -dr /lib/modules/<version>/<path>/<module-name>.ko > <module-name>.decoded
</pre>
command and attach this module dump as well. Note, that the string
<pre>
EIP: [<c05d575b>] ip_route_output_slow+0x40/0x6fa SS:ESP 0068:cf73bbbc
</pre>
also contains the function name, that can also belong to some module.

[[Category:Kernel]]
[[Category:HOWTO]]

Things we will have in 2.6.26 kernel

2008-05-29T10:40:41Z

Xemul: raw table

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
* persistent TUNs (should actually work, need CPT tunables)
* DCCP protocol
* Netfilter RAW(6) table in Containers

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)
* SCTP protocol (feature request: {{B|400}})

[[Category: Kernel]]

Things we will have in 2.6.26 kernel

2008-05-28T16:27:57Z

Xemul: flowlabels

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
* persistent TUNs (should actually work, need CPT tunables)
* DCCP protocol
* ipv6 flowlabels

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)
* SCTP protocol (feature request: {{B|400}})

[[Category: Kernel]]

Things we will have in 2.6.26 kernel

2008-04-17T06:43:58Z

Xemul: SCTP proto

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
* persistent TUNs (should actually work, need CPT tunes)
* DCCP protocol

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)
* SCTP protocol ([http://bugzilla.openvz.org/show_bug.cgi?id=400 Feature request])

Things we will have in 2.6.26 kernel

2008-04-17T06:42:30Z

Xemul: DCCP

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
* persistent TUNs (should actually work, need CPT tunes)
* DCCP protocol

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)

Kernel code quotes

2008-04-16T14:04:16Z

Xemul: buult-in modules owner for netlinks

Here we're collecting some funny quotes from the linux kernel code

----
<source lang="c">
.owner = THIS_MODULE, /* for consistency 8) */
</source>

:''from linux-2.6.25/net/netlink/af_netlink.c (which is '''always''' built-in)''

----
<source lang="c">
/*
* ...
* Yes, it is a memory overhead, but in 2003 AD, who cares?
*/
</source>

:''from linux-2.6.24/include/linux/netfilter_bridge/ebt_among.h''

----
<source lang="c">
#define BITS_PER_BYTE 8
</source>

:''from linux-2.6.24/include/linux/bitops.h''

----
<source lang="c">
/* "NOOP" scheduler: the best scheduler, recommended for all interfaces
under all circumstances. It is difficult to invent anything faster or
cheaper.
*/
</source>

:''from linux-2.6.24/net/sched/sch_generic.c''

----
<source lang="c">
/*
* Whee.. Weird sysv syscall.
*/
</source>

:''from linux-2.6.24/fs/filesystems.c''

----
<source lang="c">
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</source>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<source lang="c">
/* This code sucks. But you should have seen it before! --RR */
</source>

:''from linux-2.6.23/net/ipv4/route.c''

----
<source lang="c">
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</source>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<source lang="c">
/* Unfortunately we don't support this one. Any brave souls? */
</source>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<source lang="c">
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</source>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<source lang="c">
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</source>

:''from linux-2.6.23/kernel/exit.c''

----
<source lang="c">
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</source>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<source lang="c">
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</source>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Things we will have in 2.6.26 kernel

2008-04-16T13:59:32Z

Xemul: persistent TUNs

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
* persistent TUNs (should actually work, need CPT tunes)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:54:18Z

Xemul: oops :)

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:52:18Z

Xemul: proc files rework

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
** <code>packet</code> (now absent)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* <code>/proc/net</code> files
** sockstat file in CT (currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:51:44Z

Xemul: proc files

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* <code>/proc/net</code> files
** <code>netlink</code> (now absent)
** <code>packet</code> (now absent)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* /proc/net/sockstat file in CT (this one is currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:50:32Z

Xemul: fixed file path

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* /proc/net/netlink file (it is now absent)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* /proc/net/sockstat file in CT (this one is currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:50:01Z

Xemul: netlink proc file

This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel.

== Already in ==

* Tunnels
** IPv4-over-IPv4 (<code>ipip</code>)
** IPv4-over-GRE (<code>ip_gre</code>)
** IPv6-over-IPv4 (<code>sit</code>) ''already exists in 2.6.24''
** IP-in-IPv6 (<code>RFC2473</code>)
* ipv6 flowlabels
* /proc/net/netlink file (it is now absent)

== Sent for RFC ==

* BSD process accounting

== Planned ==

* /proc/sockstat file in CT (this one is currently empty)

Things we will have in 2.6.26 kernel

2008-04-16T13:46:01Z

Xemul: flowlabels for ipv6

Things we will have in 2.6.26 kernel

2008-04-16T13:39:40Z

Xemul: /proc/sockstat

Things we will have in 2.6.26 kernel

2008-04-16T11:40:48Z

Xemul: New page: This page describes the functionality that we've done for mainstream and are going to have in coming 2.6.26-based OpenVZ kernel. == Already in == * Tunnels ** IPv4-over-IPv4 (<code>ipip<...

Containers/Mini-summit 2008

2008-03-26T14:39:19Z

Xemul: Added "small namespaces"

There will be a containers mini-summit at the [http://www.linuxsymposium.org/2008/ OLS'08]. This page is for organizing this mini-summit. Feel free to edit.

'''When''': 21st or 22nd of July 2008<br/>
'''Where''': Ottawa, ON, Canada.

== Proposal ==

The mini-summit proposal sent to OLS organizers. See [[/Proposal|proposal]].

== Topics to discuss ==

* Device accessibility cgroup (maybe with remap ability)
* TTYs
* Syslog
* Checkpoint/restart
* Memory controllers
* more?..

== List of attendees ==
Please fill in your name here if you are going to attend, or email kir at openvz dot org if you are too lazy. Surely the list is not final, so put your name even if you are not sure you can make it.

This list is in no particular order.


<div style="-moz-column-count:3; -webkit-column-count:3; column-count:3; text-align: left; background: #fefef0; border: 1px solid #ddddc0;">
# Kir Kolyshkin
# Pavel Emelyanov
# Denis Lunev
# Andrey Mirkin
# Serge Hallyn
# Dave Hansen
# Cedric Le Goater
# Daniel Lezcano
# Srivatsa Vaddagiri
# Balbir Singh
# Sukadev Bhattiprolu
# Paul Menage
# Eric W. Biederman
# Oren Laadan
# Yamamoto Takashi
# Kamezawa Hiroyuki
# Benjamin Thery
# Herbert Pötzl
# Oleg Nesterov
# Dhaval Giani
</div>

== Agenda ==

* Namespaces/Containers
** Additional needed namespaces
*** Small namespaces ''What to do with small subsystem that might need virtualization. E.g. in openvz we have FUSE, binfmt_misc and some other small stuff virtualized. But how to merge it in mainline? Create a separate namespace for each? Mere them into one? How to call this then?''
** Nature of a 'container' — kernel object or userspace fiction
** Handling of /proc and /sysfs within containers
** Handling filesystem/namespace synchronization (not sure what the issue is)
** How to enter a container
** User namespaces?
* Cgroups+Resource management
** Cgroup implementation
** Additional cgroups and their design
** Resource management
* Checkpoint/Restart
** Summary of existing c/r patchsets/designs
** How to initiate and synchronize checkpoint/restart
** (state of freezer subsystem?)
** Memory state dump
** How to dump/fetch data for resource (file, ipc) checkpoint
** How to do restart

== See also ==
* http://www.linuxsymposium.org/2008/cfp.php — OLS call for papers
* https://lists.linux-foundation.org/pipermail/containers/2008-January/009688.html

[[Category: Containers]]
[[Category: Events]]

Kernel code quotes

2008-03-03T10:03:22Z

Xemul: EBTABLES memory overhead attitude

Here we're collecting some funny quotes from the linux kernel code

----
<source lang="c">
/*
* ...
* Yes, it is a memory overhead, but in 2003 AD, who cares?
*/
</source>

:''from linux-2.6.24/include/linux/netfilter_bridge/ebt_among.h''

----
<source lang="c">
#define BITS_PER_BYTE 8
</source>

:''from linux-2.6.24/include/linux/bitops.h''

----
<source lang="c">
/* "NOOP" scheduler: the best scheduler, recommended for all interfaces
under all circumstances. It is difficult to invent anything faster or
cheaper.
*/
</source>

:''from linux-2.6.24/net/sched/sch_generic.c''

----
<source lang="c">
/*
* Whee.. Weird sysv syscall.
*/
</source>

:''from linux-2.6.24/fs/filesystems.c''

----
<source lang="c">
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</source>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<source lang="c">
/* This code sucks. But you should have seen it before! --RR */
</source>

:''from linux-2.6.23/net/ipv4/route.c''

----
<source lang="c">
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</source>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<source lang="c">
/* Unfortunately we don't support this one. Any brave souls? */
</source>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<source lang="c">
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</source>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<source lang="c">
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</source>

:''from linux-2.6.23/kernel/exit.c''

----
<source lang="c">
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</source>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<source lang="c">
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</source>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2008-02-14T08:21:32Z

Xemul: extra line removed

Here we're collecting some funny quotes from the linux kernel code

----
<source lang="c">
#define BITS_PER_BYTE 8
</source>

:''from linux-2.6.24/include/linux/bitops.h''

----
<source lang="c">
/* "NOOP" scheduler: the best scheduler, recommended for all interfaces
under all circumstances. It is difficult to invent anything faster or
cheaper.
*/
</source>

:''from linux-2.6.24/net/sched/sch_generic.c''

----
<source lang="c">
/*
* Whee.. Weird sysv syscall.
*/
</source>

:''from linux-2.6.24/fs/filesystems.c''

----
<source lang="c">
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</source>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<source lang="c">
/* This code sucks. But you should have seen it before! --RR */
</source>

:''from linux-2.6.23/net/ipv4/route.c''

----
<source lang="c">
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</source>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<source lang="c">
/* Unfortunately we don't support this one. Any brave souls? */
</source>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<source lang="c">
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</source>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<source lang="c">
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</source>

:''from linux-2.6.23/kernel/exit.c''

----
<source lang="c">
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</source>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<source lang="c">
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</source>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2008-02-13T14:55:53Z

Xemul: bits per page

Kernel code quotes

2008-02-13T11:33:58Z

Xemul: noop scheduler

Here we're collecting some funny quotes from the linux kernel code

----
<source lang="c">
/* "NOOP" scheduler: the best scheduler, recommended for all interfaces
under all circumstances. It is difficult to invent anything faster or
cheaper.
*/
</source>

:''from linux-2.6.24/net/sched/sch_generic.c''

----
<source lang="c">
/*
* Whee.. Weird sysv syscall.
*/
</source>

:''from linux-2.6.24/fs/filesystems.c''

----
<source lang="c">
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</source>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<source lang="c">
/* This code sucks. But you should have seen it before! --RR */
</source>

:''from linux-2.6.23/net/ipv4/route.c''

----
<source lang="c">
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</source>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<source lang="c">
/* Unfortunately we don't support this one. Any brave souls? */
</source>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<source lang="c">
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</source>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<source lang="c">
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</source>

:''from linux-2.6.23/kernel/exit.c''

----
<source lang="c">
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</source>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<source lang="c">
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</source>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2008-02-07T13:14:44Z

Xemul: Weird sysfs call

Here we're collecting some funny quotes from the linux kernel code

----
<source lang="c">
/*
* Whee.. Weird sysv syscall.
*/
</source>

:''from linux-2.6.24/fs/filesystes.c''

----
<source lang="c">
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</source>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<source lang="c">
/* This code sucks. But you should have seen it before! --RR */
</source>

:''from linux-2.6.23/net/ipv4/route.c''

----
<source lang="c">
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</source>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<source lang="c">
/* Unfortunately we don't support this one. Any brave souls? */
</source>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<source lang="c">
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</source>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<source lang="c">
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</source>

:''from linux-2.6.23/kernel/exit.c''

----
<source lang="c">
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</source>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<source lang="c">
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</source>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Containers/Mini-summit 2008

2008-01-28T14:47:24Z

Xemul: Eric W.

There are plans to organize a containers mini-summit at the OLS'08. This page is for organizing this mini-summit. Feel free to edit.

'''When''': before 23rd of July 2008 (on a day before the OLS itself)<br/>
'''Where''': Ottawa, ON, Canada.

== Proposal ==

A mini-summit proposal to be sent to OLS organizers. See [[{{PAGENAME}}/Proposal]].

== Topics to discuss ==

* device accessibility cgroup (maybe with remap ability)
* ttys
* syslog
* checkpoint/restart
* more?..

== List of attendees ==
Please fill in your name here if you are going to attend, or email kir at openvz dot org if you are too lazy. Surely the list is not final, so put your name even if you are not sure you can make it.

This list is in no particular order.


<div style="-moz-column-count:3; -webkit-column-count:3; column-count:3; text-align: left; background: #fefef0; border: 1px solid #ddddc0;">
# Kir Kolyshkin
# Pavel Emelyanov
# Denis Lunev
# Andrey Mirkin
# Serge Hallyn
# Dave Hansen
# Cedric Le Goater
# Daniel Lezcano
# Srivatsa Vaddagiri
# Balbir Singh
# Sukadev Bhattiprolu
# Paul Menage
# Eric W. Biederman
</div>

== Agenda ==

TODO

== See also ==
* http://www.linuxsymposium.org/2008/cfp.php — OLS call for papers
* https://lists.linux-foundation.org/pipermail/containers/2008-January/009688.html

[[Category: Containers]]
[[Category: Events]]

Containers/Mini-summit 2008

2008-01-28T14:47:02Z

Xemul: fixed devices

There are plans to organize a containers mini-summit at the OLS'08. This page is for organizing this mini-summit. Feel free to edit.

'''When''': before 23rd of July 2008 (on a day before the OLS itself)<br/>
'''Where''': Ottawa, ON, Canada.

== Proposal ==

A mini-summit proposal to be sent to OLS organizers. See [[{{PAGENAME}}/Proposal]].

== Topics to discuss ==

* device accessibility cgroup (maybe with remap ability)
* ttys
* syslog
* checkpoint/restart
* more?..

== List of attendees ==
Please fill in your name here if you are going to attend, or email kir at openvz dot org if you are too lazy. Surely the list is not final, so put your name even if you are not sure you can make it.

This list is in no particular order.


<div style="-moz-column-count:3; -webkit-column-count:3; column-count:3; text-align: left; background: #fefef0; border: 1px solid #ddddc0;">
# Kir Kolyshkin
# Pavel Emelyanov
# Denis Lunev
# Andrey Mirkin
# Serge Hallyn
# Dave Hansen
# Cedric Le Goater
# Daniel Lezcano
# Srivatsa Vaddagiri
# Balbir Singh
# Sukadev Bhattiprolu
# Paul Menage
# Eric Biederman
</div>

== Agenda ==

TODO

== See also ==
* http://www.linuxsymposium.org/2008/cfp.php — OLS call for papers
* https://lists.linux-foundation.org/pipermail/containers/2008-January/009688.html

[[Category: Containers]]
[[Category: Events]]

Basic operations in OpenVZ environment

2008-01-08T07:12:41Z

Xemul: Added sections

This article assumes you have already [[Quick installation|installed OpenVZ]] and prepared the [[OS template cache]](s). If not, follow the links to perform the steps needed.

== Create and start a VE ==

To create and start a [[VE]], run the following commands:
<pre>
[host-node]# vzctl create VEID --ostemplate osname
[host-node]# vzctl set VEID --ipadd a.b.c.d --save
[host-node]# vzctl set VEID --nameserver a.b.c.d --save
[host-node]# vzctl start VEID
</pre>

Here <tt>VEID</tt> is the numeric ID for the VE; <tt>osname</tt> is the name of the OS template for the VE, and <tt>a.b.c.d</tt> is the IP address to be assigned to the VE.

Example:
<pre>
[host-node]# vzctl create 101 --ostemplate fedora-core-5-minimal
[host-node]# vzctl set 101 --ipadd 10.1.2.3 --save
[host-node]# vzctl set 101 --nameserver 10.0.2.1 --save
[host-node]# vzctl start 101
</pre>

Your freshly-created VE should be up and running now; you can see its processes:

<pre>
[host-node]# vzctl exec VEID ps ax
</pre>

== Enter to and exit from the VE ==

To enter VE give the following command:
<pre>
[host-node]# vzctl enter VEID
entered into VPS VEID
[ve]#
</pre>

To exit from VE, just type <code>exit</code> and press enter:
<pre>
[ve]# exit
exited from VPS VEID

[host-node]#
</pre>

== Stop and destroy the VE ==

To stop VE:

<pre>
[host-node]# vzctl stop VEID
Stopping VPS ...
VPS was stopped
VPS is unmounted
</pre>

And to destroy VE:
<pre>
[host-node]# vzctl destroy VEID
Destroying VPS private area: /vz/private/VEID
VPS private area was destroyed
</pre>

Now, when you know how to manage your [[VE]], learn about [[Resource management]].

[[Category: Installation]]
[[Category: HOWTO]]

Kernel code quotes

2007-12-12T12:21:50Z

Xemul: vlan buggyright

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
static char vlan_copyright[] = "...";
static char vlan_buggyright[] = "...";
</pre>

:''from linux-2.6.24-rc5/net/8021q/vlan.c''

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<pre>
/* This code sucks. But you should have seen it before! --RR */
</pre>

:''from linux-2.6.23/net/ipv4/route.c''

----
<pre>
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</pre>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<pre>
/* Unfortunately we don't support this one. Any brave souls? */
</pre>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-12-12T10:24:29Z

Xemul: arp comment

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
So... these "amateur" devices are hopeless.
</pre>

:''from linux-2.6.24-rc5/net/ipv4/arp.c:arp_constructor()''

----
<pre>
/* This code sucks. But you should have seen it before! --RR */
</pre>

:''from linux-2.6.23/net/ipv4/route.c''

----
<pre>
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</pre>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<pre>
/* Unfortunately we don't support this one. Any brave souls? */
</pre>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-12-04T13:18:08Z

Xemul: Added RR comment about sucking code

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
/* This code sucks. But you should have seen it before! --RR */
</pre>

:''from linux-2.6.23/net/ipv4/route.c''

----
<pre>
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</pre>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<pre>
/* Unfortunately we don't support this one. Any brave souls? */
</pre>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-29T16:39:15Z

Xemul: LOOOOOOONG error report

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
printk(KERN_DEBUG "dn_long_error_report: called\n");
kfree_skb(skb);
}
</pre>

:''from linux-2.6.23/net/decnet/dn_neigh.c''

----
<pre>
/* Unfortunately we don't support this one. Any brave souls? */
</pre>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-29T13:21:00Z

Xemul: Added forward csum

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
/* Unfortunately we don't support this one. Any brave souls? */
</pre>

:''from linux-2.6.23/include/linux/skbuff.h:skb_forward_csum()''

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-28T13:09:42Z

Xemul: new true/false macros :)

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
#define IT_ID_SET 1
#define IT_ID_NOT_SET 0
</pre>

:''from linux-2.6.23/kernel/posix-timers.c''

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-28T12:55:12Z

Xemul: Orphanned pgrp

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
* "I ask you, have you ever known what it is to be an orphan?"
*/
static int will_become_orphaned_pgrp(...
</pre>

:''from linux-2.6.23/kernel/exit.c''

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-12T15:32:12Z

Xemul: Perfect world from gre

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
#ifndef I_WISH_WORLD_WERE_PERFECT

/* It is not :-( ...
</pre>

:''from linux-2.6.23/net/ipv4/ip_gre.c:ipgre_err()''

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-07T14:51:22Z

Xemul: Added packet quote

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
weird, but documented
</pre>

:''from linux-2.6.23/net/packet/af_packet.c:packet_create()''

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-07T13:37:49Z

Xemul: Added ANK comment in af_unix.c

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
What the above comment does talk about? --ANK(980817)
</pre>

:''from linux-2.6.23/net/unix/af_unix.c:unix_release_sock()''

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]

Kernel code quotes

2007-11-07T07:39:47Z

Xemul: Add them upside-down to make new quotes appear at the top

Here we're collecting some funny quotes from the linux kernel code

----
<pre>
static inline int sk_hashed(const struct sock *sk)
{
return !sk_unhashed(sk);
}
</pre>

:''from linux-2.6.23/include/net/sock.h''

----
<pre>
Instead of using a dedicated spinlock, we (ab)use inetsw_lock
</pre>

:''from linux-2.6.23/net/ipv4/af_inet.c:build_ehash_secret()''

[[Category: Kernel]]