From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?B?TWF0dGhpZXUgRmVydHLDqQ==?= Subject: Re: [PATCH 3/9] Introduce context structure needed during checkpointing/restart Date: Wed, 03 Sep 2008 14:29:09 +0200 Message-ID: <48BE8315.6030907@irisa.fr> References: <1220439476-16465-1-git-send-email-major@openvz.org> <1220439476-16465-2-git-send-email-major@openvz.org> <1220439476-16465-3-git-send-email-major@openvz.org> <1220439476-16465-4-git-send-email-major@openvz.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1220439476-16465-4-git-send-email-major-GEFAQzZX7r8dnm+yROfE0A@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: containers-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Errors-To: containers-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org To: Andrey Mirkin Cc: containers-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: containers.vger.kernel.org QW5kcmV5IE1pcmtpbiBhIMOpY3JpdCA6Cj4gQWRkIGZ1bmN0aW9ucyBmb3IgY29udGV4dCBhbGxv Y2F0aW9uL2Rlc3Ryb3kuCj4gSW50cm9kdWNlIGZ1bmN0aW9ucyB0byByZWFkL3dyaXRlIGltYWdl Lgo+IEludHJvZHVjZSBpbWFnZSBoZWFkZXIgYW5kIG9iamVjdCBoZWFkZXIuCj4KPiBTaWduZWQt b2ZmLWJ5OiBBbmRyZXkgTWlya2luIDxtYWpvckBvcGVudnoub3JnPgo+IC0tLQo+ICBjcHQvY3B0 LmggICAgICAgfCAgIDM3ICsrKysrKysrKysrKysrKysKPiAgY3B0L2NwdF9pbWFnZS5oIHwgICA2 MyArKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgY3B0L3N5cy5jICAgICAgIHwgIDEyNyAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiAg MyBmaWxlcyBjaGFuZ2VkLCAyMjQgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGNwdC9jcHRfaW1hZ2UuaAo+Cj4gZGlmZiAtLWdpdCBhL2NwdC9jcHQu aCBiL2NwdC9jcHQuaAo+IGluZGV4IDM4MWE5YmYuLjYwN2FjMWIgMTAwNjQ0Cj4gLS0tIGEvY3B0 L2NwdC5oCj4gKysrIGIvY3B0L2NwdC5oCj4gQEAgLTEwLDYgKzEwLDggQEAKPiAgICoKPiAgICov Cj4gIAo+ICsjaW5jbHVkZSAiY3B0X2ltYWdlLmgiCj4gKwo+ICBzdHJ1Y3QgY3B0X29wZXJhdGlv bnMKPiAgewo+ICAJc3RydWN0IG1vZHVsZSAqIG93bmVyOwo+IEBAIC0xNywzICsxOSwzOCBAQCBz dHJ1Y3QgY3B0X29wZXJhdGlvbnMKPiAgCWludCAoKnJlc3RhcnQpKGludCBjdGlkLCBpbnQgZmQs IHVuc2lnbmVkIGxvbmcgZmxhZ3MpOwo+ICB9Owo+ICBleHRlcm4gc3RydWN0IGNwdF9vcGVyYXRp b25zIGNwdF9vcHM7Cj4gKwo+ICsjZGVmaW5lIENQVF9DVFhfRVJST1IgICAgICAgICAgIC0xCj4g KyNkZWZpbmUgQ1BUX0NUWF9JRExFICAgICAgICAgICAgMAo+ICsjZGVmaW5lIENQVF9DVFhfRFVN UElORyAgICAgICAgIDEKPiArI2RlZmluZSBDUFRfQ1RYX1VORFVNUElORyAgICAgICAyCj4gICAK Ck1heWJlIHlvdSBjYW4gZGVmaW5lIGFuIGVudW0gaGVyZSBpbnN0ZWFkLgoKCj4gKwo+ICt0eXBl ZGVmIHN0cnVjdCBjcHRfY29udGV4dAo+ICt7Cj4gKwlwaWRfdAkJcGlkOwkJLyogc2hvdWxkIGJl IGNoYW5nZWQgdG8gY3RpZCBsYXRlciAqLwo+ICsJaW50CQljdHhfaWQ7CQkvKiBjb250ZXh0IGlk ICovCj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIGN0eF9saXN0Owo+ICsJaW50CQlyZWZjb3VudDsKPiAr CWludAkJY3R4X3N0YXRlOwo+ICAgCgpJdCB3aWxsIGJlIG1vcmUgY2xlYXIgdGhhdCBjdHhfc3Rh dGUgcmVmZXJzIHRvIGl0LgoKVGhhbmtzLAoKTWF0dGhpZXUKCgo+ICsJc3RydWN0IHNlbWFwaG9y ZSBtYWluX3NlbTsKPiArCj4gKwlpbnQJCWVycm5vOwo+ICsKPiArCXN0cnVjdCBmaWxlCSpmaWxl Owo+ICsJbG9mZl90CQljdXJyZW50X29iamVjdDsKPiArCj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIG9i amVjdF9hcnJheVtDUFRfT0JKX01BWF07Cj4gKwo+ICsJaW50CQkoKndyaXRlKShjb25zdCB2b2lk ICphZGRyLCBzaXplX3QgY291bnQsIHN0cnVjdCBjcHRfY29udGV4dCAqY3R4KTsKPiArCWludAkJ KCpyZWFkKSh2b2lkICphZGRyLCBzaXplX3QgY291bnQsIHN0cnVjdCBjcHRfY29udGV4dCAqY3R4 KTsKPiArfSBjcHRfY29udGV4dF90Owo+ICsKPiArZXh0ZXJuIGludCBkZWJ1Z19sZXZlbDsKPiAr Cj4gKyNkZWZpbmUgY3B0X3ByaW50ayhsdmwsIGZtdCwgYXJncy4uLikJZG8gewlcCj4gKwkJaWYg KGx2bCA8PSBkZWJ1Z19sZXZlbCkJCVwKPiArCQkJcHJpbnRrKGZtdCwgIyNhcmdzKTsJXAo+ICsJ fSB3aGlsZSAoMCkKPiArCj4gKyNkZWZpbmUgZXByaW50ayhhLi4uKSBjcHRfcHJpbnRrKDEsICJD UFQgRVJSOiAiIGEpCj4gKyNkZWZpbmUgZHByaW50ayhhLi4uKSBjcHRfcHJpbnRrKDEsICJDUFQg REJHOiAiIGEpCj4gZGlmZiAtLWdpdCBhL2NwdC9jcHRfaW1hZ2UuaCBiL2NwdC9jcHRfaW1hZ2Uu aAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uM2QyNjIyOQo+IC0tLSAv ZGV2L251bGwKPiArKysgYi9jcHQvY3B0X2ltYWdlLmgKPiBAQCAtMCwwICsxLDYzIEBACj4gKy8q Cj4gKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggUGFyYWxsZWxzLCBJbmMuCj4gKyAqCj4gKyAqICBB dXRob3I6IEFuZHJleSBNaXJraW4gPG1ham9yQG9wZW52ei5vcmc+Cj4gKyAqCj4gKyAqICBUaGlz IHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y Cj4gKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBhcwo+ICsgKiAgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIHZlcnNpb24gMiBvZiB0aGUKPiArICogIExpY2Vuc2UuCj4gKyAqCj4gKyAqLwo+ICsK PiArI2lmbmRlZiBfX0NQVF9JTUFHRV9IXwo+ICsjZGVmaW5lIF9fQ1BUX0lNQUdFX0hfIDEKPiAr Cj4gK2VudW0gX2NwdF9vYmplY3RfdHlwZQo+ICt7Cj4gKwlDUFRfT0JKX1RBU0sgPSAwLAo+ICsJ Q1BUX09CSl9NQVgsCj4gKwkvKiBUaGUgb2JqZWN0cyBhYm92ZSBhcmUgc3RvcmVkIGluIG1lbW9y eSB3aGlsZSBjaGVja3BvaW50aW5nICovCj4gKwo+ICsJQ1BUX09CSl9IRUFEID0gMTAyNCwKPiAr fTsKPiArCj4gK2VudW0gX2NwdF9jb250ZW50X3R5cGUgewo+ICsJQ1BUX0NPTlRFTlRfVk9JRCwK PiArCUNQVF9DT05URU5UX0FSUkFZLAo+ICsJQ1BUX0NPTlRFTlRfREFUQSwKPiArCUNQVF9DT05U RU5UX05BTUUsCj4gKwlDUFRfQ09OVEVOVF9SRUYsCj4gKwlDUFRfQ09OVEVOVF9NQVgKPiArfTsK PiArCj4gKyNkZWZpbmUgQ1BUX1NJR05BVFVSRTAgMHg3OQo+ICsjZGVmaW5lIENQVF9TSUdOQVRV UkUxIDB4MWMKPiArI2RlZmluZSBDUFRfU0lHTkFUVVJFMiAweDAxCj4gKyNkZWZpbmUgQ1BUX1NJ R05BVFVSRTMgMHg2Mwo+ICsKPiArc3RydWN0IGNwdF9oZWFkCj4gK3sKPiArCV9fdTgJY3B0X3Np Z25hdHVyZVs0XTsJLyogTWFnaWMgbnVtYmVyICovCj4gKwlfX3UzMgljcHRfaGRybGVuOwkJLyog SGVhZGVyIGxlbmd0aCAqLwo+ICsJX191MTYJY3B0X2ltYWdlX21ham9yOwkvKiBGb3JtYXQgb2Yg dGhpcyBmaWxlICovCj4gKwlfX3UxNgljcHRfaW1hZ2VfbWlub3I7CS8qIEZvcm1hdCBvZiB0aGlz IGZpbGUgKi8KPiArCV9fdTE2CWNwdF9pbWFnZV9zdWJsZXZlbDsJLyogRm9ybWF0IG9mIHRoaXMg ZmlsZSAqLwo+ICsJX191MTYJY3B0X2ltYWdlX2V4dHJhOwkvKiBGb3JtYXQgb2YgdGhpcyBmaWxl ICovCj4gKwlfX3UxNgljcHRfYXJjaDsJCS8qIEFyY2hpdGVjdHVyZSAqLwo+ICsJX191MTYJY3B0 X3BhZDE7Cj4gKwlfX3UzMgljcHRfcGFkMjsKPiArI2RlZmluZSBDUFRfQVJDSF9JMzg2CQkwCj4g KwlfX3U2NAljcHRfdGltZTsJCS8qIFRpbWUgKi8KPiArfSBfX2F0dHJpYnV0ZV9fICgoYWxpZ25l ZCAoOCkpKTsKPiArCj4gKy8qIENvbW1vbiBvYmplY3QgaGVhZGVyLiAqLwo+ICtzdHJ1Y3QgY3B0 X29iamVjdF9oZHIKPiArewo+ICsJX191NjQJY3B0X2xlbjsJCS8qIFNpemUgb2YgY3VycmVudCBj aHVuayBvZiBkYXRhICovCj4gKwlfX3UxNgljcHRfdHlwZTsJCS8qIFR5cGUgb2Ygb2JqZWN0ICov Cj4gKwlfX3UzMgljcHRfaGRybGVuOwkJLyogU2l6ZSBvZiBoZWFkZXIgKi8KPiArCV9fdTE2CWNw dF9jb250ZW50OwkJLyogQ29udGVudCB0eXBlOiBhcnJheSwgcmVmZXJlbmNlLi4uICovCj4gK30g X19hdHRyaWJ1dGVfXyAoKGFsaWduZWQgKDgpKSk7Cj4gKwo+ICsjZW5kaWYgLyogX19DUFRfSU1B R0VfSF8gKi8KPiBkaWZmIC0tZ2l0IGEvY3B0L3N5cy5jIGIvY3B0L3N5cy5jCj4gaW5kZXggNDA1 MTI4Ni4uODMzNGM0YyAxMDA2NDQKPiAtLS0gYS9jcHQvc3lzLmMKPiArKysgYi9jcHQvc3lzLmMK PiBAQCAtMTMsMjEgKzEzLDE0MiBAQAo+ICAjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KPiAgI2lu Y2x1ZGUgPGxpbnV4L2ZzLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9maWxlLmg+Cj4gLSNpbmNsdWRl IDxsaW51eC9ub3RpZmllci5oPgo+ICsjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgo+ICAjaW5j bHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gIAo+ICAjaW5jbHVkZSAiY3B0LmgiCj4gKyNpbmNsdWRl ICJjcHRfaW1hZ2UuaCIKPiAgCj4gIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKPiAgCj4gKy8qIERl YnVnIGxldmVsLCBjb25zdGFudCBmb3Igbm93ICovCj4gK2ludCBkZWJ1Z19sZXZlbCA9IDE7Cj4g Kwo+ICtzdGF0aWMgaW50IGZpbGVfd3JpdGUoY29uc3Qgdm9pZCAqYWRkciwgc2l6ZV90IGNvdW50 LCBzdHJ1Y3QgY3B0X2NvbnRleHQgKmN0eCkKPiArewo+ICsJbW1fc2VnbWVudF90IG9sZGZzOwo+ ICsJc3NpemVfdCBlcnIgPSAtRUJBREY7Cj4gKwlzdHJ1Y3QgZmlsZSAqZmlsZSA9IGN0eC0+Zmls ZTsKPiArCj4gKwlvbGRmcyA9IGdldF9mcygpOyBzZXRfZnMoS0VSTkVMX0RTKTsKPiArCWlmIChm aWxlKQo+ICsJCWVyciA9IGZpbGUtPmZfb3AtPndyaXRlKGZpbGUsIGFkZHIsIGNvdW50LCAmZmls ZS0+Zl9wb3MpOwo+ICsJc2V0X2ZzKG9sZGZzKTsKPiArCWlmIChlcnIgIT0gY291bnQpCj4gKwkJ cmV0dXJuIGVyciA+PSAwID8gLUVJTyA6IGVycjsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtz dGF0aWMgaW50IGZpbGVfcmVhZCh2b2lkICphZGRyLCBzaXplX3QgY291bnQsIHN0cnVjdCBjcHRf Y29udGV4dCAqY3R4KQo+ICt7Cj4gKwltbV9zZWdtZW50X3Qgb2xkZnM7Cj4gKwlzc2l6ZV90IGVy ciA9IC1FQkFERjsKPiArCXN0cnVjdCBmaWxlICpmaWxlID0gY3R4LT5maWxlOwo+ICsKPiArCW9s ZGZzID0gZ2V0X2ZzKCk7IHNldF9mcyhLRVJORUxfRFMpOwo+ICsJaWYgKGZpbGUpCj4gKwkJZXJy ID0gZmlsZS0+Zl9vcC0+cmVhZChmaWxlLCBhZGRyLCBjb3VudCwgJmZpbGUtPmZfcG9zKTsKPiAr CXNldF9mcyhvbGRmcyk7Cj4gKwlpZiAoZXJyICE9IGNvdW50KQo+ICsJCXJldHVybiBlcnIgPj0g MCA/IC1FSU8gOiBlcnI7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RydWN0IGNwdF9jb250 ZXh0ICogY29udGV4dF9hbGxvYyh2b2lkKQo+ICt7Cj4gKwlzdHJ1Y3QgY3B0X2NvbnRleHQgKmN0 eDsKPiArCWludCBpOwo+ICsKPiArCWN0eCA9IGt6YWxsb2Moc2l6ZW9mKCpjdHgpLCBHRlBfS0VS TkVMKTsKPiArCWlmICghY3R4KQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCWluaXRfTVVURVgo JmN0eC0+bWFpbl9zZW0pOwo+ICsJY3R4LT5yZWZjb3VudCA9IDE7Cj4gKwo+ICsJY3R4LT5jdXJy ZW50X29iamVjdCA9IC0xOwo+ICsJY3R4LT53cml0ZSA9IGZpbGVfd3JpdGU7Cj4gKwljdHgtPnJl YWQgPSBmaWxlX3JlYWQ7Cj4gKwlmb3IgKGkgPSAwOyBpIDwgQ1BUX09CSl9NQVg7IGkrKykgewo+ ICsJCUlOSVRfTElTVF9IRUFEKCZjdHgtPm9iamVjdF9hcnJheVtpXSk7Cj4gKwl9Cj4gKwo+ICsJ cmV0dXJuIGN0eDsKPiArfQo+ICsKPiArdm9pZCBjb250ZXh0X3JlbGVhc2Uoc3RydWN0IGNwdF9j b250ZXh0ICpjdHgpCj4gK3sKPiArCWN0eC0+Y3R4X3N0YXRlID0gQ1BUX0NUWF9FUlJPUjsKPiAr Cj4gKwlpZiAoY3R4LT5maWxlKQo+ICsJCWZwdXQoY3R4LT5maWxlKTsKPiArCWtmcmVlKGN0eCk7 Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGNvbnRleHRfcHV0KHN0cnVjdCBjcHRfY29udGV4dCAq Y3R4KQo+ICt7Cj4gKwlpZiAoIS0tY3R4LT5yZWZjb3VudCkKPiArCQljb250ZXh0X3JlbGVhc2Uo Y3R4KTsKPiArfQo+ICsKPiAgc3RhdGljIGludCBjaGVja3BvaW50KHBpZF90IHBpZCwgaW50IGZk LCB1bnNpZ25lZCBsb25nIGZsYWdzKQo+ICB7Cj4gLQlyZXR1cm4gLUVOT1NZUzsgCj4gKwlzdHJ1 Y3QgZmlsZSAqZmlsZTsKPiArCXN0cnVjdCBjcHRfY29udGV4dCAqY3R4Owo+ICsJaW50IGVycjsK PiArCj4gKwllcnIgPSAtRUJBREY7Cj4gKwlmaWxlID0gZmdldChmZCk7Cj4gKwlpZiAoIWZpbGUp Cj4gKwkJZ290byBvdXQ7Cj4gKwo+ICsJZXJyID0gLUVOT01FTTsKPiArCWN0eCA9IGNvbnRleHRf YWxsb2MoKTsKPiArCWlmICghY3R4KQo+ICsJCWdvdG8gb3V0X2ZpbGU7Cj4gKwo+ICsJY3R4LT5m aWxlID0gZmlsZTsKPiArCWN0eC0+Y3R4X3N0YXRlID0gQ1BUX0NUWF9EVU1QSU5HOwo+ICsKPiAr CS8qIGNoZWNrcG9pbnQgKi8KPiArCWVyciA9IC1FTk9TWVM7Cj4gKwo+ICsJY29udGV4dF9wdXQo Y3R4KTsKPiArCj4gK291dF9maWxlOgo+ICsJZnB1dChmaWxlKTsKPiArb3V0Ogo+ICsJcmV0dXJu IGVycjsgCj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQgcmVzdGFydChpbnQgY3RpZCwgaW50IGZkLCB1 bnNpZ25lZCBsb25nIGZsYWdzKQo+ICB7Cj4gLQlyZXR1cm4gLUVOT1NZUzsgCj4gKwlzdHJ1Y3Qg ZmlsZSAqZmlsZTsKPiArCXN0cnVjdCBjcHRfY29udGV4dCAqY3R4Owo+ICsJaW50IGVycjsKPiAr Cj4gKwllcnIgPSAtRUJBREY7Cj4gKwlmaWxlID0gZmdldChmZCk7Cj4gKwlpZiAoIWZpbGUpCj4g KwkJZ290byBvdXQ7Cj4gKwo+ICsJZXJyID0gLUVOT01FTTsKPiArCWN0eCA9IGNvbnRleHRfYWxs b2MoKTsKPiArCWlmICghY3R4KQo+ICsJCWdvdG8gb3V0X2ZpbGU7Cj4gKwo+ICsJY3R4LT5maWxl ID0gZmlsZTsKPiArCWN0eC0+Y3R4X3N0YXRlID0gQ1BUX0NUWF9VTkRVTVBJTkc7Cj4gKwo+ICsJ LyogcmVzdGFydCAqLwo+ICsJZXJyID0gLUVOT1NZUzsKPiArCj4gKwljb250ZXh0X3B1dChjdHgp Owo+ICsKPiArb3V0X2ZpbGU6Cj4gKwlmcHV0KGZpbGUpOwo+ICtvdXQ6Cj4gKwlyZXR1cm4gZXJy OyAKPiAgfQo+ICAKPiAgc3RhdGljIGludCBfX2luaXQgaW5pdF9jcHRyc3Qodm9pZCkKPiAgIAoK Ci0tIApNYXR0aGlldSBGZXJ0csOpCgpJUklTQSwgQ2FtcHVzIHVuaXZlcnNpdGFpcmUgZGUgQmVh dWxpZXUgLSAzNSAwNDIgUmVubmVzLCBGcmFuY2UKdGVsOiArMzMgMiA5OSA4NCAyMiA3NApmYXg6 ICszMyAyIDk5IDg0IDcxIDcxCm1haWw6IG1mZXJ0cmVAaXJpc2EuZnIKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkNvbnRhaW5lcnMgbWFpbGluZyBsaXN0 CkNvbnRhaW5lcnNAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51 eC1mb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2NvbnRhaW5lcnM= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755045AbYICMjS (ORCPT ); Wed, 3 Sep 2008 08:39:18 -0400 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1751703AbYICMjJ (ORCPT ); Wed, 3 Sep 2008 08:39:09 -0400 Received: from mail2-relais-roc.national.inria.fr ([192.134.164.83]:52872 "EHLO mail2-relais-roc.national.inria.fr" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751648AbYICMjI (ORCPT ); Wed, 3 Sep 2008 08:39:08 -0400 X-Greylist: delayed 593 seconds by postgrey-1.27 at vger.kernel.org; Wed, 03 Sep 2008 08:39:07 EDT X-IronPort-AV: E=Sophos;i="4.32,320,1217800800"; d="scan'208";a="14525672" Message-ID: <48BE8315.6030907@irisa.fr> Date: Wed, 03 Sep 2008 14:29:09 +0200 From: =?UTF-8?B?TWF0dGhpZXUgRmVydHLDqQ==?= User-Agent: Thunderbird 2.0.0.16 (X11/20080724) MIME-Version: 1.0 To: Andrey Mirkin CC: linux-kernel@vger.kernel.org, containers@lists.linux-foundation.org Subject: Re: [PATCH 3/9] Introduce context structure needed during checkpointing/restart References: <1220439476-16465-1-git-send-email-major@openvz.org> <1220439476-16465-2-git-send-email-major@openvz.org> <1220439476-16465-3-git-send-email-major@openvz.org> <1220439476-16465-4-git-send-email-major@openvz.org> In-Reply-To: <1220439476-16465-4-git-send-email-major@openvz.org> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Andrey Mirkin a écrit : > Add functions for context allocation/destroy. > Introduce functions to read/write image. > Introduce image header and object header. > > Signed-off-by: Andrey Mirkin > --- > cpt/cpt.h | 37 ++++++++++++++++ > cpt/cpt_image.h | 63 +++++++++++++++++++++++++++ > cpt/sys.c | 127 +++++++++++++++++++++++++++++++++++++++++++++++++++++- > 3 files changed, 224 insertions(+), 3 deletions(-) > create mode 100644 cpt/cpt_image.h > > diff --git a/cpt/cpt.h b/cpt/cpt.h > index 381a9bf..607ac1b 100644 > --- a/cpt/cpt.h > +++ b/cpt/cpt.h > @@ -10,6 +10,8 @@ > * > */ > > +#include "cpt_image.h" > + > struct cpt_operations > { > struct module * owner; > @@ -17,3 +19,38 @@ struct cpt_operations > int (*restart)(int ctid, int fd, unsigned long flags); > }; > extern struct cpt_operations cpt_ops; > + > +#define CPT_CTX_ERROR -1 > +#define CPT_CTX_IDLE 0 > +#define CPT_CTX_DUMPING 1 > +#define CPT_CTX_UNDUMPING 2 > Maybe you can define an enum here instead. > + > +typedef struct cpt_context > +{ > + pid_t pid; /* should be changed to ctid later */ > + int ctx_id; /* context id */ > + struct list_head ctx_list; > + int refcount; > + int ctx_state; > It will be more clear that ctx_state refers to it. Thanks, Matthieu > + struct semaphore main_sem; > + > + int errno; > + > + struct file *file; > + loff_t current_object; > + > + struct list_head object_array[CPT_OBJ_MAX]; > + > + int (*write)(const void *addr, size_t count, struct cpt_context *ctx); > + int (*read)(void *addr, size_t count, struct cpt_context *ctx); > +} cpt_context_t; > + > +extern int debug_level; > + > +#define cpt_printk(lvl, fmt, args...) do { \ > + if (lvl <= debug_level) \ > + printk(fmt, ##args); \ > + } while (0) > + > +#define eprintk(a...) cpt_printk(1, "CPT ERR: " a) > +#define dprintk(a...) cpt_printk(1, "CPT DBG: " a) > diff --git a/cpt/cpt_image.h b/cpt/cpt_image.h > new file mode 100644 > index 0000000..3d26229 > --- /dev/null > +++ b/cpt/cpt_image.h > @@ -0,0 +1,63 @@ > +/* > + * Copyright (C) 2008 Parallels, Inc. > + * > + * Author: Andrey Mirkin > + * > + * This program is free software; you can redistribute it and/or > + * modify it under the terms of the GNU General Public License as > + * published by the Free Software Foundation, version 2 of the > + * License. > + * > + */ > + > +#ifndef __CPT_IMAGE_H_ > +#define __CPT_IMAGE_H_ 1 > + > +enum _cpt_object_type > +{ > + CPT_OBJ_TASK = 0, > + CPT_OBJ_MAX, > + /* The objects above are stored in memory while checkpointing */ > + > + CPT_OBJ_HEAD = 1024, > +}; > + > +enum _cpt_content_type { > + CPT_CONTENT_VOID, > + CPT_CONTENT_ARRAY, > + CPT_CONTENT_DATA, > + CPT_CONTENT_NAME, > + CPT_CONTENT_REF, > + CPT_CONTENT_MAX > +}; > + > +#define CPT_SIGNATURE0 0x79 > +#define CPT_SIGNATURE1 0x1c > +#define CPT_SIGNATURE2 0x01 > +#define CPT_SIGNATURE3 0x63 > + > +struct cpt_head > +{ > + __u8 cpt_signature[4]; /* Magic number */ > + __u32 cpt_hdrlen; /* Header length */ > + __u16 cpt_image_major; /* Format of this file */ > + __u16 cpt_image_minor; /* Format of this file */ > + __u16 cpt_image_sublevel; /* Format of this file */ > + __u16 cpt_image_extra; /* Format of this file */ > + __u16 cpt_arch; /* Architecture */ > + __u16 cpt_pad1; > + __u32 cpt_pad2; > +#define CPT_ARCH_I386 0 > + __u64 cpt_time; /* Time */ > +} __attribute__ ((aligned (8))); > + > +/* Common object header. */ > +struct cpt_object_hdr > +{ > + __u64 cpt_len; /* Size of current chunk of data */ > + __u16 cpt_type; /* Type of object */ > + __u32 cpt_hdrlen; /* Size of header */ > + __u16 cpt_content; /* Content type: array, reference... */ > +} __attribute__ ((aligned (8))); > + > +#endif /* __CPT_IMAGE_H_ */ > diff --git a/cpt/sys.c b/cpt/sys.c > index 4051286..8334c4c 100644 > --- a/cpt/sys.c > +++ b/cpt/sys.c > @@ -13,21 +13,142 @@ > #include > #include > #include > -#include > +#include > #include > > #include "cpt.h" > +#include "cpt_image.h" > > MODULE_LICENSE("GPL"); > > +/* Debug level, constant for now */ > +int debug_level = 1; > + > +static int file_write(const void *addr, size_t count, struct cpt_context *ctx) > +{ > + mm_segment_t oldfs; > + ssize_t err = -EBADF; > + struct file *file = ctx->file; > + > + oldfs = get_fs(); set_fs(KERNEL_DS); > + if (file) > + err = file->f_op->write(file, addr, count, &file->f_pos); > + set_fs(oldfs); > + if (err != count) > + return err >= 0 ? -EIO : err; > + return 0; > +} > + > +static int file_read(void *addr, size_t count, struct cpt_context *ctx) > +{ > + mm_segment_t oldfs; > + ssize_t err = -EBADF; > + struct file *file = ctx->file; > + > + oldfs = get_fs(); set_fs(KERNEL_DS); > + if (file) > + err = file->f_op->read(file, addr, count, &file->f_pos); > + set_fs(oldfs); > + if (err != count) > + return err >= 0 ? -EIO : err; > + return 0; > +} > + > +struct cpt_context * context_alloc(void) > +{ > + struct cpt_context *ctx; > + int i; > + > + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); > + if (!ctx) > + return NULL; > + > + init_MUTEX(&ctx->main_sem); > + ctx->refcount = 1; > + > + ctx->current_object = -1; > + ctx->write = file_write; > + ctx->read = file_read; > + for (i = 0; i < CPT_OBJ_MAX; i++) { > + INIT_LIST_HEAD(&ctx->object_array[i]); > + } > + > + return ctx; > +} > + > +void context_release(struct cpt_context *ctx) > +{ > + ctx->ctx_state = CPT_CTX_ERROR; > + > + if (ctx->file) > + fput(ctx->file); > + kfree(ctx); > +} > + > +static void context_put(struct cpt_context *ctx) > +{ > + if (!--ctx->refcount) > + context_release(ctx); > +} > + > static int checkpoint(pid_t pid, int fd, unsigned long flags) > { > - return -ENOSYS; > + struct file *file; > + struct cpt_context *ctx; > + int err; > + > + err = -EBADF; > + file = fget(fd); > + if (!file) > + goto out; > + > + err = -ENOMEM; > + ctx = context_alloc(); > + if (!ctx) > + goto out_file; > + > + ctx->file = file; > + ctx->ctx_state = CPT_CTX_DUMPING; > + > + /* checkpoint */ > + err = -ENOSYS; > + > + context_put(ctx); > + > +out_file: > + fput(file); > +out: > + return err; > } > > static int restart(int ctid, int fd, unsigned long flags) > { > - return -ENOSYS; > + struct file *file; > + struct cpt_context *ctx; > + int err; > + > + err = -EBADF; > + file = fget(fd); > + if (!file) > + goto out; > + > + err = -ENOMEM; > + ctx = context_alloc(); > + if (!ctx) > + goto out_file; > + > + ctx->file = file; > + ctx->ctx_state = CPT_CTX_UNDUMPING; > + > + /* restart */ > + err = -ENOSYS; > + > + context_put(ctx); > + > +out_file: > + fput(file); > +out: > + return err; > } > > static int __init init_cptrst(void) > -- Matthieu Fertré IRISA, Campus universitaire de Beaulieu - 35 042 Rennes, France tel: +33 2 99 84 22 74 fax: +33 2 99 84 71 71 mail: mfertre@irisa.fr