From mboxrd@z Thu Jan 1 00:00:00 1970 From: Richard Weinberger Subject: Re: [PATCH v7 1/2] procfs: show hierarchy of pid namespace Date: Wed, 12 Nov 2014 12:15:10 +0100 Message-ID: <5463413E.6000800@nod.at> References: <1415786899-13392-1-git-send-email-chenhanxiao@cn.fujitsu.com> <1415786899-13392-2-git-send-email-chenhanxiao@cn.fujitsu.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1415786899-13392-2-git-send-email-chenhanxiao-BthXqXjhjHXQFUHtdCDX3A@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: Chen Hanxiao , "Eric W. Biederman" , Serge Hallyn , Oleg Nesterov Cc: Richard Weinberger , containers-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mateusz Guzik , David Howells List-Id: containers.vger.kernel.org QW0gMTIuMTEuMjAxNCB1bSAxMTowOCBzY2hyaWViIENoZW4gSGFueGlhbzoKPiBXZSBsYWNrIG9m IHBpZCBoaWVyYXJjaHkgaW5mb3JtYXRpb24sIGFuZCB0aGlzIHdpbGwgbGVhZCB0bzoKPiBhKSB3 ZSBkb24ndCBrbm93IHBpZHMnIHJlbGF0aW9uc2hpcCwgd2hvIGlzIHdob3NlIGNoaWxkOgo+ICAg IC9wcm9jL1BJRC9ucy9waWQgb25seSB0ZWxsIHVzIHdoZXRoZXIgdHdvIHBpZHMgbGl2ZSBpbiBk aWZmZXJlbnQgbnMKPiBiKSBicmluZyB0cm91YmxlIHRvIG5lc3RlZCBseGMgY29udGFpbmVyIGNo ZWNrL3Jlc3RvcmUvbWlncmF0aW9uCj4gYykgYnJpbmcgdHJvdWJsZSB0byBwaWQgdHJhbnNsYXRp b24gYmV0d2VlbiBjb250YWluZXJzOwo+IAo+IFRoaXMgcGF0Y2ggd2lsbCBzaG93IHRoZSBoaWVy YXJjaHkgb2YgcGlkIG5hbWVzcGFjZQo+IGJ5IHBpZG5zX2hpZXJhcmNoeSBsaWtlOgo+IAo+IDxp bml0X1BJRD4gPHBhcmVudF9vZl9pbml0X1BJRD4gPHJlbGF0aXZlIFBJRCBsZXZlbD4KPiAKPiBF eDoKPiBbcm9vdEBsb2NhbGhvc3Qgfl0jY2F0IC9wcm9jL3BpZG5zX2hpZXJhcmNoeQo+IDE4MDYw IDEgMQo+IDE4MTAyIDE4MDYwIDIKPiAxNTM0ICAxODEwMiAzCj4gMTYwMCAgMTgxMDIgMwo+IDE1 NTAgIDEgMQo+ICpOb3RlOiBudW1iZXJzIHJlcHJlc2VudCB0aGUgcGlkIDEgaW4gZGlmZmVyZW50 IG5zCj4gCj4gSXQgc2hvd3MgdGhlIHBpZCBoaWVyYXJjaHkgYmVsb3c6Cj4gCj4gICAgICAgaW5p dF9waWRfbnMgMQo+ICAgICAgICAgICAgICAg4pSCCj4g4pSM4pSA4pSA4pSA4pSA4pSA4pSA4pSA 4pSA4pSA4pSA4pSA4pSA4pSQCj4gbnMxICAgICAgICAgICAgICAgICAgICAgIG5zMgo+IOKUgiAg ICAgICAgICAgICAgICAgICAgICAgIOKUggo+IDE1NTAgICAgICAgICAgICAgICAgICAgIDE4MDYw Cj4gICAgICAgICAgICAgICAgICAgICAgICAgICDilIIKPiAgICAgICAgICAgICAgICAgICAgICAg ICAgIOKUggo+ICAgICAgICAgICAgICAgICAgICAgICAgICBuczMKPiAgICAgICAgICAgICAgICAg ICAgICAgICAgIOKUggo+ICAgICAgICAgICAgICAgICAgICAgICAgIDE4MTAyCj4gICAgICAgICAg ICAgICAgICAgICAgICAgICDilIIKPiAgICAgICAgICAgICAgICAgIOKUjOKUgOKUgOKUgOKUgOKU gOKUgOKUgOKUgOKUgOKUgOKUkAo+ICAgICAgICAgICAgICAgICAgbnM0ICAgICAgICAgICAgICAg ICAgIG5zNQo+ICAgICAgICAgICAgICAgICAg4pSCICAgICAgICAgICAgICAgICAgICDilIIKPiAg ICAgICAgICAgICAgICAgMTUzNCAgICAgICAgICAgICAgICAgIDE2MDAKPiAKPiBFdmVyeSBwaWQg cHJpbnRlZCBpbiBwaWRuc19oaWVyYXJjaHkKPiBpcyB0aGUgaW5pdCBwaWQgb2YgdGhhdCBwaWQg bnMgbGV2ZWwuCj4gCj4gU2lnbmVkLW9mZi1ieTogQ2hlbiBIYW54aWFvIDxjaGVuaGFueGlhb0Bj bi5mdWppdHN1LmNvbT4KPiAtLS0KPiB2NzogY2hhbmdlIHN0eXBlIHRvIGJlIGNvbnNpc3RlbnQg d2l0aCBjdXJyZW50IGludGVyZmFjZSBsaWtlCj4gICAgIDxpbml0X1BJRD4gPHBhcmVudF9vZl9p bml0X1BJRD4gPHJlbGF0aXZlIFBJRCBsZXZlbD4KPiAgICAgcmVtb3ZlIEVYUEVSVCBkZXBlbmRl bnQgaW4gS2NvbmZpZwo+IHY2OiBmaXggYSBnZXRfcGlkIGxlYWsgYW5kIGRvIHNvbWUgY2xlYW51 cHM7Cj4gdjU6IGNvbGxlY3QgcGlkIGJ5IGZpbmRfZ2VfcGlkOwo+ICAgICB1c2UgbG9jYWwgbGlz dCBpbnNpZGUgbnNsaXN0X3Byb2Nfc2hvdzsKPiAgICAgdXNlIGdldF9waWQsIHJlbW92ZSBtdXRl eCBsb2NrLgo+IHY0OiBzaW1wbGlmeSBwaWQgY29sbGVjdGlvbiBhbmQgc29tZSBwZXJmb3JtYW5j ZSBvcHRpbWl6YW10aW9uCj4gICAgIGZpeCBhbm90aGVyIHJhY2UgaXNzdWUuCj4gdjM6IGZpeCBh IHJhY2UgaXNzdWUgYW5kIG1lbW9yeSBsZWFrIGlzc3VlCj4gdjI6IHVzZSBhIHByb2NmcyB0ZXh0 IGZpbGUgaW5zdGVhZCBvZiBkaXJzIHVuZGVyIC9wcm9jCj4gCj4gIGZzL3Byb2MvS2NvbmZpZyAg ICAgICAgICAgfCAgIDYgKwo+ICBmcy9wcm9jL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKPiAg ZnMvcHJvYy9waWRuc19oaWVyYXJjaHkuYyB8IDI4MCArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCj4gIDMgZmlsZXMgY2hhbmdlZCwgMjg3IGluc2VydGlvbnMo KykKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGZzL3Byb2MvcGlkbnNfaGllcmFyY2h5LmMKPiAKPiBk aWZmIC0tZ2l0IGEvZnMvcHJvYy9LY29uZmlnIGIvZnMvcHJvYy9LY29uZmlnCj4gaW5kZXggMjE4 M2ZjZi4uODJkZGE1NSAxMDA2NDQKPiAtLS0gYS9mcy9wcm9jL0tjb25maWcKPiArKysgYi9mcy9w cm9jL0tjb25maWcKPiBAQCAtNzEsMyArNzEsOSBAQCBjb25maWcgUFJPQ19QQUdFX01PTklUT1IK PiAgCSAgL3Byb2MvcGlkL3NtYXBzLCAvcHJvYy9waWQvY2xlYXJfcmVmcywgL3Byb2MvcGlkL3Bh Z2VtYXAsCj4gIAkgIC9wcm9jL2twYWdlY291bnQsIGFuZCAvcHJvYy9rcGFnZWZsYWdzLiBEaXNh YmxpbmcgdGhlc2UKPiAgICAgICAgICAgIGludGVyZmFjZXMgd2lsbCByZWR1Y2UgdGhlIHNpemUg b2YgdGhlIGtlcm5lbCBieSBhcHByb3hpbWF0ZWx5IDRrYi4KPiArCj4gK2NvbmZpZyBQUk9DX1BJ RF9ISUVSQVJDSFkKPiArCWJvb2wgIkVuYWJsZSAvcHJvYy9waWRuc19oaWVyYXJjaHkgc3VwcG9y dCIKPiArCWRlcGVuZHMgb24gUFJPQ19GUwo+ICsJaGVscAo+ICsJICBTaG93IHBpZCBuYW1lc3Bh Y2UgaGllcmFyY2h5IGluZm9ybWF0aW9uCj4gZGlmZiAtLWdpdCBhL2ZzL3Byb2MvTWFrZWZpbGUg Yi9mcy9wcm9jL01ha2VmaWxlCj4gaW5kZXggNzE1MWVhNC4uMzNlMzg0YiAxMDA2NDQKPiAtLS0g YS9mcy9wcm9jL01ha2VmaWxlCj4gKysrIGIvZnMvcHJvYy9NYWtlZmlsZQo+IEBAIC0zMCwzICsz MCw0IEBAIHByb2MtJChDT05GSUdfUFJPQ19LQ09SRSkJKz0ga2NvcmUubwo+ICBwcm9jLSQoQ09O RklHX1BST0NfVk1DT1JFKQkrPSB2bWNvcmUubwo+ICBwcm9jLSQoQ09ORklHX1BSSU5USykJKz0g a21zZy5vCj4gIHByb2MtJChDT05GSUdfUFJPQ19QQUdFX01PTklUT1IpCSs9IHBhZ2Uubwo+ICtw cm9jLSQoQ09ORklHX1BST0NfUElEX0hJRVJBUkNIWSkJKz0gcGlkbnNfaGllcmFyY2h5Lm8KPiBk aWZmIC0tZ2l0IGEvZnMvcHJvYy9waWRuc19oaWVyYXJjaHkuYyBiL2ZzL3Byb2MvcGlkbnNfaGll cmFyY2h5LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjQ2MjliZmQK PiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZnMvcHJvYy9waWRuc19oaWVyYXJjaHkuYwo+IEBAIC0w LDAgKzEsMjgwIEBACj4gKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9lcnJuby5oPgo+ICsjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9waWRfbmFtZXNwYWNlLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9zZXFfZmlsZS5oPgo+ICsKPiArLyoKPiArICogIC9wcm9jL3BpZG5zX2hpZXJhcmNo eQo+ICsgKgo+ICsgKiAgc2hvdyB0aGUgaGllcmFyY2h5IG9mIHBpZCBuYW1lc3BhY2UgaW46Cj4g KyAqICA8aW5pdF9QSUQ+ICA8cGFyZW50X29mX2luaXRfUElEPiA8cmVsYXRpdmUgUElEIGxldmVs Pgo+ICsgKgo+ICsgKiAgaW5pdF9QSUQ6IGNoaWxkIHJlYXBlciBpbiBucwo+ICsgKiAgcGFyZW50 X29mX2luaXRfUElEOiBpbml0X1BJRCdzIHBhcmVudCwgYWxzbyBjaGlsZCByZWFwZXIKPiArICog IHJlbGF0aXZlIFBJRCBsZXZlbDogcGlkIGxldmVsIHJlbGF0aXZlIHRvIGNhbGxlcidzIG5zCj4g KyAqLwo+ICsKPiArI2RlZmluZSBOU19ISUVSQVJDSFkJInBpZG5zX2hpZXJhcmNoeSIKPiArI2Rl ZmluZSBNQVgoYSwgYikgKChhKSA+IChiKSA/IChhKSA6IChiKSkKClBsZWFzZSB1c2UgbWF4KCkg ZnJvbSBrZXJuZWwuaCwgdGhlcmUgaXMgbm8gbmVlZCB0byByZWludmVudCB0aGUgd2hlZWwuCgo+ ICsKPiArLyogbGlzdCBmb3IgaG9zdCBwaWQgY29sbGVjdGlvbiAqLwo+ICtzdHJ1Y3QgcGlkbnNf bGlzdCB7Cj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7Cj4gKwlzdHJ1Y3QgcGlkICpwaWQ7Cj4g KwlpbnQgc2hvd19sZXZlbDsKCnMvc2hvd19sZXZlbC9sZXZlbCwgdG8ga2VlcCBpdCBlYXN5LiA6 LSkKCj4gK307Cj4gKwo+ICtzdGF0aWMgdm9pZCBmcmVlX3BpZG5zX2xpc3Qoc3RydWN0IGxpc3Rf aGVhZCAqaGVhZCkKPiArewo+ICsJc3RydWN0IHBpZG5zX2xpc3QgKnRtcCwgKnBvczsKPiArCj4g KwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocG9zLCB0bXAsIGhlYWQsIGxpc3QpIHsKPiArCQls aXN0X2RlbCgmcG9zLT5saXN0KTsKPiArCQlwdXRfcGlkKHBvcy0+cGlkKTsKPiArCQlrZnJlZShw b3MpOwo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50Cj4gK3BpZG5zX2xpc3RfYWRkKHN0cnVj dCBwaWQgKnBpZCwgc3RydWN0IGxpc3RfaGVhZCAqbGlzdF9oZWFkLAo+ICsJCWludCBzaG93X2xl dmVsKQo+ICt7Cj4gKwlzdHJ1Y3QgcGlkbnNfbGlzdCAqZW50Owo+ICsKPiArCWVudCA9IGttYWxs b2Moc2l6ZW9mKCplbnQpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghZW50KQo+ICsJCXJldHVybiAt RU5PTUVNOwo+ICsKPiArCWVudC0+cGlkID0gcGlkOwo+ICsJZW50LT5zaG93X2xldmVsID0gc2hv d19sZXZlbDsKPiArCWxpc3RfYWRkX3RhaWwoJmVudC0+bGlzdCwgbGlzdF9oZWFkKTsKPiArCj4g KwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludAo+ICtwaWRuc19saXN0X2ZpbHRlcihz dHJ1Y3QgbGlzdF9oZWFkICpwaWRuc19waWRfbGlzdCwKPiArCQlzdHJ1Y3QgbGlzdF9oZWFkICpw aWRuc19waWRfdHJlZSkKPiArewo+ICsJc3RydWN0IHBpZG5zX2xpc3QgKnBvcywgKnBvc190Owo+ ICsJc3RydWN0IHBpZF9uYW1lc3BhY2UgKm5zMCwgKm5zMTsKPiArCXN0cnVjdCBwaWQgKnBpZDAs ICpwaWQxOwo+ICsJaW50IHJjLCBmbGFnID0gMDsKPiArCj4gKwkvKgo+ICsJICogc2NyZWVuIHBp ZHMgd2l0aCByZWxhdGlvbnNoaXAKPiArCSAqIGluIHBpZG5zX3BpZF9saXN0LCB3ZSBtYXkgYWRk IHBpZHMgbGlrZToKPiArCSAqIG5zMCAgIG5zMSAgIG5zMgo+ICsJICogcGlkMS0+cGlkMi0+cGlk Mwo+ICsJICogd2Ugc2hvdWxkIHNjcmVlbiBwaWQxLCBwaWQyIGFuZCBrZWVwIHBpZDMKPiArCSAq Lwo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeShwb3MsIHBpZG5zX3BpZF9saXN0LCBsaXN0KSB7Cj4g KwkJbGlzdF9mb3JfZWFjaF9lbnRyeShwb3NfdCwgcGlkbnNfcGlkX2xpc3QsIGxpc3QpIHsKPiAr CQkJZmxhZyA9IDA7Cj4gKwkJCXBpZDAgPSBwb3MtPnBpZDsKPiArCQkJcGlkMSA9IHBvc190LT5w aWQ7Cj4gKwkJCW5zMCA9IHBpZDAtPm51bWJlcnNbcGlkMC0+bGV2ZWxdLm5zOwo+ICsJCQluczEg PSBwaWQxLT5udW1iZXJzW3BpZDEtPmxldmVsXS5uczsKPiArCQkJaWYgKHBvcy0+cGlkLT5sZXZl bCA8IHBvc190LT5waWQtPmxldmVsKQo+ICsJCQkJZm9yICg7IG5zMSAhPSBOVUxMOyBuczEgPSBu czEtPnBhcmVudCkKPiArCQkJCQlpZiAobnMwID09IG5zMSkgewo+ICsJCQkJCQlmbGFnID0gMTsK PiArCQkJCQkJYnJlYWs7Cj4gKwkJCQkJfQo+ICsJCQkvKiBhIHJlZHVuZGFudCBwaWQgZm91bmQg Ki8KPiArCQkJaWYgKGZsYWcgPT0gMSkKPiArCQkJCWJyZWFrOwo+ICsJCX0KPiArCj4gKwkJaWYg KGZsYWcgPT0gMCkgewo+ICsJCQlnZXRfcGlkKHBvcy0+cGlkKTsKPiArCQkJcmMgPSBwaWRuc19s aXN0X2FkZChwb3MtPnBpZCwgcGlkbnNfcGlkX3RyZWUsIDApOwo+ICsJCQlpZiAocmMpIHsKPiAr CQkJCXB1dF9waWQocG9zLT5waWQpOwo+ICsJCQkJZ290byBjbGVhbnVwOwo+ICsJCQl9Cj4gKwkJ fQo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiAgTm93IGFsbCB1c2VmdWwgc3R1ZmZzIGFyZSBpbiBw aWRuc19waWRfdHJlZSwKPiArCSAqICBmcmVlIHBpZG5zX3BpZF9saXN0Cj4gKwkgKi8KPiArCWZy ZWVfcGlkbnNfbGlzdChwaWRuc19waWRfbGlzdCk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtj bGVhbnVwOgo+ICsJZnJlZV9waWRuc19saXN0KHBpZG5zX3BpZF90cmVlKTsKPiArCXJldHVybiBy YzsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQKPiArcGlkbnNfbGlzdF9zZXRfc2hvd19sZXZlbChz dHJ1Y3QgbGlzdF9oZWFkICpwaWRuc19saXN0X2luLAo+ICsJCXN0cnVjdCBwaWRfbmFtZXNwYWNl ICpjdXJyX25zKQo+ICt7Cj4gKwlzdHJ1Y3QgcGlkbnNfbGlzdCAqcG9zLCAqcG9zX3Q7Cj4gKwlz dHJ1Y3QgcGlkICpwaWQwLCAqcGlkMTsKPiArCWludCBpOwo+ICsKPiArCS8qCj4gKwkgKiBGcm9t IHRoZSBwaWQgaGllcmFyY2h5IHBvaW50IG9mIHZpZXcsCj4gKwkgKiB3ZSBhbHJlYWR5IGhhZCBh IGxpc3Qgb2YgcGlkcyB3aG8gYXJlIG5vdAo+ICsJICogdGhlIHN1YnNldCBvZiBlYWNoIG90aGVy Lgo+ICsJICogQnV0IHBhcnQgb2YgdGhlbSBtYXkgYmUgc2FtZS4KPiArCSAqIFdlIG5lZWQgdG8g c2V0IHRoZSBzaG93X2xldmVsIG9mIGVhY2ggcGlkczoKPiArCSAqIHBpZDA6ICAgICAgICAgQS0+ Qi0+QyAgIHBpZDE6ICAgICAgIEEtPkItPkQKPiArCSAqIHNob3dfbGV2ZWwgICAgICAgMiAgICAg ICAgICAgICAgICAgIDAKPiArCSAqIFdlIHVzZSBzaG93X2xldmVsIHRvIGlkZW50aWZ5Cj4gKwkg KiB0aGUgcHVibGljIHBhcnQgb2YgZWFjaCBwaWRzLgo+ICsJICovCj4gKwlsaXN0X2Zvcl9lYWNo X2VudHJ5KHBvcywgcGlkbnNfbGlzdF9pbiwgbGlzdCkgewo+ICsJCWxpc3RfZm9yX2VhY2hfZW50 cnkocG9zX3QsIHBpZG5zX2xpc3RfaW4sIGxpc3QpIHsKPiArCQkJcGlkMCA9IHBvcy0+cGlkOwo+ ICsJCQlwaWQxID0gcG9zX3QtPnBpZDsKPiArCQkJaWYgKHBpZDAgPT0gcGlkMSkKPiArCQkJCWNv bnRpbnVlOwo+ICsJCQlpZiAocG9zX3QtPnNob3dfbGV2ZWwgPiAwKQo+ICsJCQkJY29udGludWU7 Cj4gKwkJCWZvciAoaSA9IGN1cnJfbnMtPmxldmVsICsgMTsgaSA8PSBwaWQwLT5sZXZlbDsgaSsr KSB7Cj4gKwkJCQkvKiBza2lwIHRoZSBwdWJsaWMgcGFydHMgKi8KPiArCQkJCWlmIChwaWQwLT5u dW1iZXJzW2ldLm5zID09Cj4gKwkJCQkJCXBpZDEtPm51bWJlcnNbaV0ubnMpCj4gKwkJCQkJY29u dGludWU7Cj4gKwkJCQllbHNlCj4gKwkJCQkJYnJlYWs7Cj4gKwkJCX0KPiArCQkJcG9zLT5zaG93 X2xldmVsID0gaSAtIDE7Cj4gKwkJfQo+ICsJfQo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBjb2xsZWN0 IHBpZHMgYW5kIHN0b3JlZCBpbiBwaWRuc19waWRfbGlzdCwKCnMvc3RvcmVkL3N0b3JlCgo+ICsg KiB0aGVuIHJlbW92ZSBkdXBsaWNhdGVkIG9uZXMsCj4gKyAqIGFkZCB0aGUgcmVzdCB0byBwaWRu c19waWRfdHJlZQo+ICsgKi8KClRoaXMgY29tbWVudCBpcyBhIGJpdCBjb25mdXNpbmcuCgpXaGF0 IGFib3V0ICJwcm9jX3BpZG5zX2xpc3RfcmVmcmVzaCAtIEZpbmRzIGFsbCBpbml0IHBpZHMsIHBs YWNlcyB0aGVtIGludG8gcGlkbnNfcGlkX2xpc3QKYW5kIHRoZW4gc3RvcmVzIHRoZSBoaXJhcmNo eSBpbnRvIHBpZG5zX3BpZF90cmVlLiI/CgpCZXNpZGUgb2YgbXkgbWlub3IgY29tbWVudHMgSSBs aWtlIHRoZSBwYXRjaC4gOi0pClRoYW5rcyBhIGxvdCBmb3IgZG9pbmcgdGhpcyB3b3JrIQoKVGhh bmtzLAovL3JpY2hhcmQKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KQ29udGFpbmVycyBtYWlsaW5nIGxpc3QKQ29udGFpbmVyc0BsaXN0cy5saW51eC1mb3Vu ZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0 aW5mby9jb250YWluZXJz From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752611AbaKLLPW (ORCPT ); Wed, 12 Nov 2014 06:15:22 -0500 Received: from a.ns.miles-group.at ([95.130.255.143]:65275 "EHLO radon.swed.at" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751412AbaKLLPQ (ORCPT ); Wed, 12 Nov 2014 06:15:16 -0500 Message-ID: <5463413E.6000800@nod.at> Date: Wed, 12 Nov 2014 12:15:10 +0100 From: Richard Weinberger User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.1.0 MIME-Version: 1.0 To: Chen Hanxiao , "Eric W. Biederman" , Serge Hallyn , Oleg Nesterov CC: containers@lists.linux-foundation.org, linux-kernel@vger.kernel.org, David Howells , Richard Weinberger , Pavel Emelyanov , Vasiliy Kulikov , Mateusz Guzik Subject: Re: [PATCH v7 1/2] procfs: show hierarchy of pid namespace References: <1415786899-13392-1-git-send-email-chenhanxiao@cn.fujitsu.com> <1415786899-13392-2-git-send-email-chenhanxiao@cn.fujitsu.com> In-Reply-To: <1415786899-13392-2-git-send-email-chenhanxiao@cn.fujitsu.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Am 12.11.2014 um 11:08 schrieb Chen Hanxiao: > We lack of pid hierarchy information, and this will lead to: > a) we don't know pids' relationship, who is whose child: > /proc/PID/ns/pid only tell us whether two pids live in different ns > b) bring trouble to nested lxc container check/restore/migration > c) bring trouble to pid translation between containers; > > This patch will show the hierarchy of pid namespace > by pidns_hierarchy like: > > > > Ex: > [root@localhost ~]#cat /proc/pidns_hierarchy > 18060 1 1 > 18102 18060 2 > 1534 18102 3 > 1600 18102 3 > 1550 1 1 > *Note: numbers represent the pid 1 in different ns > > It shows the pid hierarchy below: > > init_pid_ns 1 > │ > ┌────────────┐ > ns1 ns2 > │ │ > 1550 18060 > │ > │ > ns3 > │ > 18102 > │ > ┌──────────┐ > ns4 ns5 > │ │ > 1534 1600 > > Every pid printed in pidns_hierarchy > is the init pid of that pid ns level. > > Signed-off-by: Chen Hanxiao > --- > v7: change stype to be consistent with current interface like > > remove EXPERT dependent in Kconfig > v6: fix a get_pid leak and do some cleanups; > v5: collect pid by find_ge_pid; > use local list inside nslist_proc_show; > use get_pid, remove mutex lock. > v4: simplify pid collection and some performance optimizamtion > fix another race issue. > v3: fix a race issue and memory leak issue > v2: use a procfs text file instead of dirs under /proc > > fs/proc/Kconfig | 6 + > fs/proc/Makefile | 1 + > fs/proc/pidns_hierarchy.c | 280 ++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 287 insertions(+) > create mode 100644 fs/proc/pidns_hierarchy.c > > diff --git a/fs/proc/Kconfig b/fs/proc/Kconfig > index 2183fcf..82dda55 100644 > --- a/fs/proc/Kconfig > +++ b/fs/proc/Kconfig > @@ -71,3 +71,9 @@ config PROC_PAGE_MONITOR > /proc/pid/smaps, /proc/pid/clear_refs, /proc/pid/pagemap, > /proc/kpagecount, and /proc/kpageflags. Disabling these > interfaces will reduce the size of the kernel by approximately 4kb. > + > +config PROC_PID_HIERARCHY > + bool "Enable /proc/pidns_hierarchy support" > + depends on PROC_FS > + help > + Show pid namespace hierarchy information > diff --git a/fs/proc/Makefile b/fs/proc/Makefile > index 7151ea4..33e384b 100644 > --- a/fs/proc/Makefile > +++ b/fs/proc/Makefile > @@ -30,3 +30,4 @@ proc-$(CONFIG_PROC_KCORE) += kcore.o > proc-$(CONFIG_PROC_VMCORE) += vmcore.o > proc-$(CONFIG_PRINTK) += kmsg.o > proc-$(CONFIG_PROC_PAGE_MONITOR) += page.o > +proc-$(CONFIG_PROC_PID_HIERARCHY) += pidns_hierarchy.o > diff --git a/fs/proc/pidns_hierarchy.c b/fs/proc/pidns_hierarchy.c > new file mode 100644 > index 0000000..4629bfd > --- /dev/null > +++ b/fs/proc/pidns_hierarchy.c > @@ -0,0 +1,280 @@ > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * /proc/pidns_hierarchy > + * > + * show the hierarchy of pid namespace in: > + * > + * > + * init_PID: child reaper in ns > + * parent_of_init_PID: init_PID's parent, also child reaper > + * relative PID level: pid level relative to caller's ns > + */ > + > +#define NS_HIERARCHY "pidns_hierarchy" > +#define MAX(a, b) ((a) > (b) ? (a) : (b)) Please use max() from kernel.h, there is no need to reinvent the wheel. > + > +/* list for host pid collection */ > +struct pidns_list { > + struct list_head list; > + struct pid *pid; > + int show_level; s/show_level/level, to keep it easy. :-) > +}; > + > +static void free_pidns_list(struct list_head *head) > +{ > + struct pidns_list *tmp, *pos; > + > + list_for_each_entry_safe(pos, tmp, head, list) { > + list_del(&pos->list); > + put_pid(pos->pid); > + kfree(pos); > + } > +} > + > +static int > +pidns_list_add(struct pid *pid, struct list_head *list_head, > + int show_level) > +{ > + struct pidns_list *ent; > + > + ent = kmalloc(sizeof(*ent), GFP_KERNEL); > + if (!ent) > + return -ENOMEM; > + > + ent->pid = pid; > + ent->show_level = show_level; > + list_add_tail(&ent->list, list_head); > + > + return 0; > +} > + > +static int > +pidns_list_filter(struct list_head *pidns_pid_list, > + struct list_head *pidns_pid_tree) > +{ > + struct pidns_list *pos, *pos_t; > + struct pid_namespace *ns0, *ns1; > + struct pid *pid0, *pid1; > + int rc, flag = 0; > + > + /* > + * screen pids with relationship > + * in pidns_pid_list, we may add pids like: > + * ns0 ns1 ns2 > + * pid1->pid2->pid3 > + * we should screen pid1, pid2 and keep pid3 > + */ > + list_for_each_entry(pos, pidns_pid_list, list) { > + list_for_each_entry(pos_t, pidns_pid_list, list) { > + flag = 0; > + pid0 = pos->pid; > + pid1 = pos_t->pid; > + ns0 = pid0->numbers[pid0->level].ns; > + ns1 = pid1->numbers[pid1->level].ns; > + if (pos->pid->level < pos_t->pid->level) > + for (; ns1 != NULL; ns1 = ns1->parent) > + if (ns0 == ns1) { > + flag = 1; > + break; > + } > + /* a redundant pid found */ > + if (flag == 1) > + break; > + } > + > + if (flag == 0) { > + get_pid(pos->pid); > + rc = pidns_list_add(pos->pid, pidns_pid_tree, 0); > + if (rc) { > + put_pid(pos->pid); > + goto cleanup; > + } > + } > + } > + > + /* > + * Now all useful stuffs are in pidns_pid_tree, > + * free pidns_pid_list > + */ > + free_pidns_list(pidns_pid_list); > + > + return 0; > + > +cleanup: > + free_pidns_list(pidns_pid_tree); > + return rc; > +} > + > +static void > +pidns_list_set_show_level(struct list_head *pidns_list_in, > + struct pid_namespace *curr_ns) > +{ > + struct pidns_list *pos, *pos_t; > + struct pid *pid0, *pid1; > + int i; > + > + /* > + * From the pid hierarchy point of view, > + * we already had a list of pids who are not > + * the subset of each other. > + * But part of them may be same. > + * We need to set the show_level of each pids: > + * pid0: A->B->C pid1: A->B->D > + * show_level 2 0 > + * We use show_level to identify > + * the public part of each pids. > + */ > + list_for_each_entry(pos, pidns_list_in, list) { > + list_for_each_entry(pos_t, pidns_list_in, list) { > + pid0 = pos->pid; > + pid1 = pos_t->pid; > + if (pid0 == pid1) > + continue; > + if (pos_t->show_level > 0) > + continue; > + for (i = curr_ns->level + 1; i <= pid0->level; i++) { > + /* skip the public parts */ > + if (pid0->numbers[i].ns == > + pid1->numbers[i].ns) > + continue; > + else > + break; > + } > + pos->show_level = i - 1; > + } > + } > +} > + > +/* > + * collect pids and stored in pidns_pid_list, s/stored/store > + * then remove duplicated ones, > + * add the rest to pidns_pid_tree > + */ This comment is a bit confusing. What about "proc_pidns_list_refresh - Finds all init pids, places them into pidns_pid_list and then stores the hirarchy into pidns_pid_tree."? Beside of my minor comments I like the patch. :-) Thanks a lot for doing this work! Thanks, //richard