From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ian Kent Subject: Re: [PATCH RFC] mnt: umount mounts one by one in umount_tree() Date: Wed, 14 Jun 2017 09:53:10 +0800 Message-ID: <1497405190.2595.3.camel@themaw.net> References: <20170512070838.5037-1-avagin@openvz.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170512070838.5037-1-avagin-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: Andrei Vagin , "Eric W . Biederman" Cc: linux-fsdevel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Linux Containers , Alexander Viro , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: containers.vger.kernel.org T24gRnJpLCAyMDE3LTA1LTEyIGF0IDAwOjA4IC0wNzAwLCBBbmRyZWkgVmFnaW4gd3JvdGU6Cj4g V2l0aCB0aGlzIHBhdGNoLCB3ZSBkb24ndCB0cnkgdG8gdW1vdW50IGFsbCBtb3VudHMgb2YgYSB0 cmVlIHRvZ2V0aGVyLgo+IEluc3RlYWQgb2YgdGhpcyB3ZSB1bW91bnQgdGhlbSBvbmUgYnkgb25l LiBJbiB0aGlzIGNhc2UsIHdlIHNlZSBhIHNpZ25pZmljYW50Cj4gaW1wcm92ZW1lbnQgaW4gcGVy Zm9ybWFuY2UgZm9yIHRoZSB3b3Jz0LUgY2FzZS4KCkluZGVlZCwgdW1vdW50IGhhcyBiZWVuIHZl cnkgc2xvdyBmb3IgYSB3aGlsZSBub3cuCkV2ZW4gYSBtb2RlcmF0ZWx5IGxhcmdlIG51bWJlciBv ZiBtb3VudHMgKH4xMDAwMCkgYmVjb21lIHBhaW5mdWxseSBzbG93LgoKUmUgeW91IHN0aWxsIHBl cnVzaW5nIHRoaXM/CkFueXRoaW5nIEkgY2FuIGRvIHRvIGhlbHA/CgpFcmljLCB3aGF0IGFyZSB5 b3VyIHRob3VnaHRzIG9uIHRoaXMgbGF0ZXN0IGF0dGVtcHQ/Cgo+IAo+IFRoZSByZWFzb24gb2Yg dGhpcyBvcHRpbWl6YXRpb24gaXMgdGhhdCB1bW91bnQoKSBjYW4gaG9sZCBuYW1lc3BhY2Vfc2Vt Cj4gZm9yIGEgbG9uZyB0aW1lLCB0aGlzIHNlbWFwaG9yZSBpcyBnbG9iYWwsIHNvIGl0IGFmZmVj dHMgYWxsIHVzZXJzLgo+IFJlY2VudGx5IEVyaWMgVy4gQmllZGVybWFuIGFkZGVkIGEgcGVyIG1v dW50IG5hbWVzcGFjZSBsaW1pdCBvbiB0aGUKPiBudW1iZXIgb2YgbW91bnRzLiBUaGUgZGVmYXVs dCBudW1iZXIgb2YgbW91bnRzIGFsbG93ZWQgcGVyIG1vdW50Cj4gbmFtZXNwYWNlIGF0IDEwMCww MDAuIEN1cnJlbnRseSB0aGlzIHZhbHVlIGlzIGFsbG93ZWQgdG8gY29uc3RydWN0IGEgdHJlZQo+ IHdoaWNoIHJlcXVpcmVzIGhvdXJzIHRvIGJlIHVtb3VudGVkLgo+IAo+IEluIGEgd29yc2UgY2Fz ZSB0aGUgY3VycmVudCBjb21wbGV4aXR5IG9mIHVtb3VudF90cmVlKCkgaXMgTyhuXjMpLgo+ICog RW51bWlyYXRlIGFsbCBtb3VudHMgaW4gYSB0YXJnZXQgdHJlZSAocHJvcGFnYXRlX3Vtb3VudCkK PiAqIEVudW1pcmF0ZSBtb3VudHMgdG8gZmluZCB3aGVyZSB0aGVzZSBjaGFuZ2VzIGhhdmUgdG8K PiDCoCBiZSBwcm9wYWdhdGVkIChtYXJrX3Vtb3VudF9jYW5kaWRhdGVzKQo+ICogRW51bWlyYXRl IG1vdW50cyB0byBmaW5kIGEgcmVxdWVyZWQgbW91bnQgYnkgcGFyZW50IGFuZCBkZW50cnkKPiDC oCAoX19sb29rdXBfbW50KS4gX19sb29rdXBfbW50KCkgc2VhcmNoZXMgYSBtb3VudCBpbiBtX2hh c2gsIGJ1dAo+IMKgIHRoZSBudW1iZXIgb2YgbW91bnRzIGlzIG11Y2ggYmlnZ2VyIHRoYW4gYSBz aXplIG9mIHRoZSBoYXNoLgo+IAo+IFRoZSB3b3JzZSBjYXNlIGlzIHdoZW4gYWxsIG1vdW50cyBm cm9tIHRoZSB0cmVlIGxpdmUgaW4gdGhlIHNhbWUgc2hhcmVkCj4gZ3JvdXAuIEluIHRoaXMgY2Fz ZSB3ZSBoYXZlIHRvIGVudW1pcmF0ZSBhbGwgbW91bnRzIG9uIGVhY2ggc3RlcC4KPiAKPiBUaGVy ZSBpcyBDVkUtMjAxNi02MjEzIGFib3V0IHRoaXMgY2FzZS4KPiAKPiBIZXJlIGFyZSByZXN1bHRz IGZvciB0aGUga2VybmVsIHdpdGggdGhpcyBwYXRjaAo+ICQgZm9yIGkgaW4gYHNlcSAxMCAxNWA7 IGRvwqDCoHVuc2hhcmUgLW0gc2ggLi9ydW4uc2ggJGk7IGRvbmUKPiB1bW91bnQgLWwgL21udC8x IC0+wqAJMDowMC4wMAo+IHVtb3VudCAtbCAvbW50LzEgLT7CoAkwOjAwLjAxCj4gdW1vdW50IC1s IC9tbnQvMSAtPsKgCTA6MDAuMDEKPiB1bW91bnQgLWwgL21udC8xIC0+wqAJMDowMC4wMwo+IHVt b3VudCAtbCAvbW50LzEgLT7CoAkwOjAwLjA3Cj4gdW1vdW50IC1sIC9tbnQvMSAtPsKgCTA6MDAu MTQKPiAKPiBIZXJlIGFyZSByZXN1bHRzIGZvciB0aGUga2VybmVsIHdpdGhvdXQgdGhpcyBwYXRj aAo+ICQgZm9yIGkgaW4gYHNlcSAxMCAxNWA7IGRvwqDCoHVuc2hhcmUgLW0gc2ggLi9ydW4uc2gg JGk7IGRvbmUKPiB1bW91bnQgLWwgL21udC8xIC0+wqAJMDowMC4wNAo+IHVtb3VudCAtbCAvbW50 LzEgLT7CoAkwOjAwLjE3Cj4gdW1vdW50IC1sIC9tbnQvMSAtPsKgCTA6MDAuNzUKPiB1bW91bnQg LWwgL21udC8xIC0+wqAJMDowNS45Ngo+IHVtb3VudCAtbCAvbW50LzEgLT7CoAkwOjM0LjQwCj4g dW1vdW50IC1sIC9tbnQvMSAtPsKgCTM6NDYuMjcKPiAKPiBBbmQgaGVyZSBpcyBhIHRlc3Qgc2Ny aXB0Ogo+ICQgY2F0IHJ1bi5zaAo+IHNldCAtZSAtbQo+IAo+IG1vdW50IC10IHRtcGZzIHpkdG0g L21udAo+IG1rZGlyIC1wIC9tbnQvMSAvbW50LzIKPiBtb3VudCAtdCB0bXBmcyB6ZHRtIC9tbnQv MQo+IG1vdW50IC0tbWFrZS1zaGFyZWQgL21udC8xCj4gbWtkaXIgL21udC8xLzEKPiAKPiBmb3Ig aSBpbiBgc2VxICQxYDsgZG8KPiAJLi9tb3VudCAtLWJpbmQgL21udC8xLzEgL21udC8xLzEKPiBk b25lCj4gCj4gZWNobyAtbiAidW1vdW50IC1sIC9tbnQvMSAtPiAiCj4gL3Vzci9iaW4vdGltZSAt ZiAnJUUnIC4vdW1vdW50IC1sIC9tbnQvMQo+IAo+IEFuZCB3ZSBuZWVkIHRoZXNlIHNpbXBsZSBt b3VudCBhbmQgdW1vdW50IHRvb2xzLCBiZWNhdXNlIHRoZSBzdGFuZGFyZAo+IG9uZXMgcmVhZCAv cHJvYy9zZWxmL21vdW50aW5mbywgYnV0IHRoaXMgaXMgZXh0cmVtZWx5IHNsb3cgd2hlbiB3ZSBo YXZlCj4gdGhvdXNhbmRzIG9mIG1vdW50cy4KPiAkIGNhdCBtb3VudC5jCj4gwqAjaW5jbHVkZSA8 c3lzL21vdW50Lmg+Cj4gwqAjaW5jbHVkZSA8c3RkbGliLmg+Cj4gCj4gwqBpbnQgbWFpbihpbnQg YXJnYywgY2hhciAqKmFyZ3YpCj4gwqB7Cj4gwqAJcmV0dXJuIG1vdW50KGFyZ3ZbMl0sIGFyZ3Zb M10sIE5VTEwsIE1TX0JJTkQsIE5VTEwpOwo+IMKgfQo+IAo+ICQgY2F0IHVtb3VudC5jCj4gwqAj aW5jbHVkZSA8c3lzL21vdW50Lmg+Cj4gCj4gwqBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqKmFy Z3YpCj4gwqB7Cj4gwqAJcmV0dXJuIHVtb3VudDIoYXJndlsyXSwgTU5UX0RFVEFDSCk7Cj4gwqB9 Cj4gCj4gSGVyZSBpcyBhIHByZXZpb3VzIGF0dGVtcHQgdG8gb3B0aW1pemUgdGhpcyBjb2RlOgo+ IGh0dHBzOi8vbGttbC5vcmcvbGttbC8yMDE2LzEwLzEwLzQ5NQo+IAo+IFNpZ25lZC1vZmYtYnk6 IEFuZHJlaSBWYWdpbiA8YXZhZ2luQG9wZW52ei5vcmc+Cj4gLS0tCj4gwqBmcy9uYW1lc3BhY2Uu YyB8IDgxICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KPiAtLS0KPiDCoDEgZmlsZSBjaGFuZ2VkLCA0MyBpbnNlcnRpb25zKCspLCAzOCBkZWxl dGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZnMvbmFtZXNwYWNlLmMgYi9mcy9uYW1lc3BhY2Uu Ywo+IGluZGV4IDNiZjBjZDIuLjRlNmYyNTggMTAwNjQ0Cj4gLS0tIGEvZnMvbmFtZXNwYWNlLmMK PiArKysgYi9mcy9uYW1lc3BhY2UuYwo+IEBAIC0xNDc0LDU2ICsxNDc0LDYxIEBAIHN0YXRpYyBi b29sIGRpc2Nvbm5lY3RfbW91bnQoc3RydWN0IG1vdW50ICptbnQsIGVudW0KPiB1bW91bnRfdHJl ZV9mbGFncyBob3cpCj4gwqAgKi8KPiDCoHN0YXRpYyB2b2lkIHVtb3VudF90cmVlKHN0cnVjdCBt b3VudCAqbW50LCBlbnVtIHVtb3VudF90cmVlX2ZsYWdzIGhvdykKPiDCoHsKPiAtCUxJU1RfSEVB RCh0bXBfbGlzdCk7Cj4gwqAJc3RydWN0IG1vdW50ICpwOwo+ICsJaW50IGRvbmUgPSAwOwo+IMKg Cj4gwqAJaWYgKGhvdyAmIFVNT1VOVF9QUk9QQUdBVEUpCj4gwqAJCXByb3BhZ2F0ZV9tb3VudF91 bmxvY2sobW50KTsKPiDCoAo+IMKgCS8qIEdhdGhlciB0aGUgbW91bnRzIHRvIHVtb3VudCAqLwo+ IC0JZm9yIChwID0gbW50OyBwOyBwID0gbmV4dF9tbnQocCwgbW50KSkgewo+ICsJd2hpbGUgKCFk b25lKSB7Cj4gKwkJTElTVF9IRUFEKHRtcF9saXN0KTsKPiArCj4gKwkJcCA9IG1udDsKPiArCQl3 aGlsZSAoIWxpc3RfZW1wdHkoJnAtPm1udF9tb3VudHMpKQo+ICsJCQlwID0gbGlzdF9lbnRyeShw LT5tbnRfbW91bnRzLm5leHQsIHN0cnVjdCBtb3VudCwKPiBtbnRfY2hpbGQpOwo+ICsKPiDCoAkJ cC0+bW50Lm1udF9mbGFncyB8PSBNTlRfVU1PVU5UOwo+IMKgCQlsaXN0X21vdmUoJnAtPm1udF9s aXN0LCAmdG1wX2xpc3QpOwo+IC0JfQo+IC0KPiAtCS8qIEhpZGUgdGhlIG1vdW50cyBmcm9tIG1u dF9tb3VudHMgKi8KPiAtCWxpc3RfZm9yX2VhY2hfZW50cnkocCwgJnRtcF9saXN0LCBtbnRfbGlz dCkgewo+IMKgCQlsaXN0X2RlbF9pbml0KCZwLT5tbnRfY2hpbGQpOwo+IC0JfQo+IMKgCj4gLQkv KiBBZGQgcHJvcG9nYXRlZCBtb3VudHMgdG8gdGhlIHRtcF9saXN0ICovCj4gLQlpZiAoaG93ICYg VU1PVU5UX1BST1BBR0FURSkKPiAtCQlwcm9wYWdhdGVfdW1vdW50KCZ0bXBfbGlzdCk7Cj4gLQo+ IC0Jd2hpbGUgKCFsaXN0X2VtcHR5KCZ0bXBfbGlzdCkpIHsKPiAtCQlzdHJ1Y3QgbW50X25hbWVz cGFjZSAqbnM7Cj4gLQkJYm9vbCBkaXNjb25uZWN0Owo+IC0JCXAgPSBsaXN0X2ZpcnN0X2VudHJ5 KCZ0bXBfbGlzdCwgc3RydWN0IG1vdW50LCBtbnRfbGlzdCk7Cj4gLQkJbGlzdF9kZWxfaW5pdCgm cC0+bW50X2V4cGlyZSk7Cj4gLQkJbGlzdF9kZWxfaW5pdCgmcC0+bW50X2xpc3QpOwo+IC0JCW5z ID0gcC0+bW50X25zOwo+IC0JCWlmIChucykgewo+IC0JCQlucy0+bW91bnRzLS07Cj4gLQkJCV9f dG91Y2hfbW50X25hbWVzcGFjZShucyk7Cj4gLQkJfQo+IC0JCXAtPm1udF9ucyA9IE5VTEw7Cj4g LQkJaWYgKGhvdyAmIFVNT1VOVF9TWU5DKQo+IC0JCQlwLT5tbnQubW50X2ZsYWdzIHw9IE1OVF9T WU5DX1VNT1VOVDsKPiAtCj4gLQkJZGlzY29ubmVjdCA9IGRpc2Nvbm5lY3RfbW91bnQocCwgaG93 KTsKPiAtCj4gLQkJcGluX2luc2VydF9ncm91cCgmcC0+bW50X3Vtb3VudCwgJnAtPm1udF9wYXJl bnQtPm1udCwKPiAtCQkJCcKgZGlzY29ubmVjdCA/ICZ1bm1vdW50ZWQgOiBOVUxMKTsKPiAtCQlp ZiAobW50X2hhc19wYXJlbnQocCkpIHsKPiAtCQkJbW50X2FkZF9jb3VudChwLT5tbnRfcGFyZW50 LCAtMSk7Cj4gLQkJCWlmICghZGlzY29ubmVjdCkgewo+IC0JCQkJLyogRG9uJ3QgZm9yZ2V0IGFi b3V0IHAgKi8KPiAtCQkJCWxpc3RfYWRkX3RhaWwoJnAtPm1udF9jaGlsZCwgJnAtPm1udF9wYXJl bnQtCj4gPm1udF9tb3VudHMpOwo+IC0JCQl9IGVsc2Ugewo+IC0JCQkJdW1vdW50X21udChwKTsK PiArCQkvKiBBZGQgcHJvcG9nYXRlZCBtb3VudHMgdG8gdGhlIHRtcF9saXN0ICovCj4gKwkJaWYg KGhvdyAmIFVNT1VOVF9QUk9QQUdBVEUpCj4gKwkJCXByb3BhZ2F0ZV91bW91bnQoJnRtcF9saXN0 KTsKPiArCj4gKwkJaWYgKHAgPT0gbW50KQo+ICsJCQlkb25lID0gMTsKPiArCj4gKwkJd2hpbGUg KCFsaXN0X2VtcHR5KCZ0bXBfbGlzdCkpIHsKPiArCQkJc3RydWN0IG1udF9uYW1lc3BhY2UgKm5z Owo+ICsJCQlib29sIGRpc2Nvbm5lY3Q7Cj4gKwkJCXAgPSBsaXN0X2ZpcnN0X2VudHJ5KCZ0bXBf bGlzdCwgc3RydWN0IG1vdW50LAo+IG1udF9saXN0KTsKPiArCQkJbGlzdF9kZWxfaW5pdCgmcC0+ bW50X2V4cGlyZSk7Cj4gKwkJCWxpc3RfZGVsX2luaXQoJnAtPm1udF9saXN0KTsKPiArCQkJbnMg PSBwLT5tbnRfbnM7Cj4gKwkJCWlmIChucykgewo+ICsJCQkJbnMtPm1vdW50cy0tOwo+ICsJCQkJ X190b3VjaF9tbnRfbmFtZXNwYWNlKG5zKTsKPiArCQkJfQo+ICsJCQlwLT5tbnRfbnMgPSBOVUxM Owo+ICsJCQlpZiAoaG93ICYgVU1PVU5UX1NZTkMpCj4gKwkJCQlwLT5tbnQubW50X2ZsYWdzIHw9 IE1OVF9TWU5DX1VNT1VOVDsKPiArCj4gKwkJCWRpc2Nvbm5lY3QgPSBkaXNjb25uZWN0X21vdW50 KHAsIGhvdyk7Cj4gKwo+ICsJCQlwaW5faW5zZXJ0X2dyb3VwKCZwLT5tbnRfdW1vdW50LCAmcC0+ bW50X3BhcmVudC0+bW50LAo+ICsJCQkJCcKgZGlzY29ubmVjdCA/ICZ1bm1vdW50ZWQgOiBOVUxM KTsKPiArCQkJaWYgKG1udF9oYXNfcGFyZW50KHApKSB7Cj4gKwkJCQltbnRfYWRkX2NvdW50KHAt Pm1udF9wYXJlbnQsIC0xKTsKPiArCQkJCWlmICghZGlzY29ubmVjdCkgewo+ICsJCQkJCS8qIERv bid0IGZvcmdldCBhYm91dCBwICovCj4gKwkJCQkJbGlzdF9hZGRfdGFpbCgmcC0+bW50X2NoaWxk LCAmcC0KPiA+bW50X3BhcmVudC0+bW50X21vdW50cyk7Cj4gKwkJCQl9IGVsc2Ugewo+ICsJCQkJ CXVtb3VudF9tbnQocCk7Cj4gKwkJCQl9Cj4gwqAJCQl9Cj4gKwkJCWNoYW5nZV9tbnRfcHJvcGFn YXRpb24ocCwgTVNfUFJJVkFURSk7Cj4gwqAJCX0KPiAtCQljaGFuZ2VfbW50X3Byb3BhZ2F0aW9u KHAsIE1TX1BSSVZBVEUpOwo+IMKgCX0KPiDCoH0KPiDCoApfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpDb250YWluZXJzIG1haWxpbmcgbGlzdApDb250YWlu ZXJzQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0 aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2NvbnRhaW5lcnM= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Message-ID: <1497405190.2595.3.camel@themaw.net> Subject: Re: [PATCH RFC] mnt: umount mounts one by one in umount_tree() From: Ian Kent To: Andrei Vagin , "Eric W . Biederman" Cc: Alexander Viro , linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, Linux Containers Date: Wed, 14 Jun 2017 09:53:10 +0800 In-Reply-To: <20170512070838.5037-1-avagin@openvz.org> References: <20170512070838.5037-1-avagin@openvz.org> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: On Fri, 2017-05-12 at 00:08 -0700, Andrei Vagin wrote: > With this patch, we don't try to umount all mounts of a tree together. > Instead of this we umount them one by one. In this case, we see a significant > improvement in performance for the worsе case. Indeed, umount has been very slow for a while now. Even a moderately large number of mounts (~10000) become painfully slow. Re you still perusing this? Anything I can do to help? Eric, what are your thoughts on this latest attempt? > > The reason of this optimization is that umount() can hold namespace_sem > for a long time, this semaphore is global, so it affects all users. > Recently Eric W. Biederman added a per mount namespace limit on the > number of mounts. The default number of mounts allowed per mount > namespace at 100,000. Currently this value is allowed to construct a tree > which requires hours to be umounted. > > In a worse case the current complexity of umount_tree() is O(n^3). > * Enumirate all mounts in a target tree (propagate_umount) > * Enumirate mounts to find where these changes have to >   be propagated (mark_umount_candidates) > * Enumirate mounts to find a requered mount by parent and dentry >   (__lookup_mnt). __lookup_mnt() searches a mount in m_hash, but >   the number of mounts is much bigger than a size of the hash. > > The worse case is when all mounts from the tree live in the same shared > group. In this case we have to enumirate all mounts on each step. > > There is CVE-2016-6213 about this case. > > Here are results for the kernel with this patch > $ for i in `seq 10 15`; do  unshare -m sh ./run.sh $i; done > umount -l /mnt/1 ->  0:00.00 > umount -l /mnt/1 ->  0:00.01 > umount -l /mnt/1 ->  0:00.01 > umount -l /mnt/1 ->  0:00.03 > umount -l /mnt/1 ->  0:00.07 > umount -l /mnt/1 ->  0:00.14 > > Here are results for the kernel without this patch > $ for i in `seq 10 15`; do  unshare -m sh ./run.sh $i; done > umount -l /mnt/1 ->  0:00.04 > umount -l /mnt/1 ->  0:00.17 > umount -l /mnt/1 ->  0:00.75 > umount -l /mnt/1 ->  0:05.96 > umount -l /mnt/1 ->  0:34.40 > umount -l /mnt/1 ->  3:46.27 > > And here is a test script: > $ cat run.sh > set -e -m > > mount -t tmpfs zdtm /mnt > mkdir -p /mnt/1 /mnt/2 > mount -t tmpfs zdtm /mnt/1 > mount --make-shared /mnt/1 > mkdir /mnt/1/1 > > for i in `seq $1`; do > ./mount --bind /mnt/1/1 /mnt/1/1 > done > > echo -n "umount -l /mnt/1 -> " > /usr/bin/time -f '%E' ./umount -l /mnt/1 > > And we need these simple mount and umount tools, because the standard > ones read /proc/self/mountinfo, but this is extremely slow when we have > thousands of mounts. > $ cat mount.c >  #include >  #include > >  int main(int argc, char **argv) >  { >   return mount(argv[2], argv[3], NULL, MS_BIND, NULL); >  } > > $ cat umount.c >  #include > >  int main(int argc, char **argv) >  { >   return umount2(argv[2], MNT_DETACH); >  } > > Here is a previous attempt to optimize this code: > https://lkml.org/lkml/2016/10/10/495 > > Signed-off-by: Andrei Vagin > --- >  fs/namespace.c | 81 +++++++++++++++++++++++++++++++------------------------ > --- >  1 file changed, 43 insertions(+), 38 deletions(-) > > diff --git a/fs/namespace.c b/fs/namespace.c > index 3bf0cd2..4e6f258 100644 > --- a/fs/namespace.c > +++ b/fs/namespace.c > @@ -1474,56 +1474,61 @@ static bool disconnect_mount(struct mount *mnt, enum > umount_tree_flags how) >   */ >  static void umount_tree(struct mount *mnt, enum umount_tree_flags how) >  { > - LIST_HEAD(tmp_list); >   struct mount *p; > + int done = 0; >   >   if (how & UMOUNT_PROPAGATE) >   propagate_mount_unlock(mnt); >   >   /* Gather the mounts to umount */ > - for (p = mnt; p; p = next_mnt(p, mnt)) { > + while (!done) { > + LIST_HEAD(tmp_list); > + > + p = mnt; > + while (!list_empty(&p->mnt_mounts)) > + p = list_entry(p->mnt_mounts.next, struct mount, > mnt_child); > + >   p->mnt.mnt_flags |= MNT_UMOUNT; >   list_move(&p->mnt_list, &tmp_list); > - } > - > - /* Hide the mounts from mnt_mounts */ > - list_for_each_entry(p, &tmp_list, mnt_list) { >   list_del_init(&p->mnt_child); > - } >   > - /* Add propogated mounts to the tmp_list */ > - if (how & UMOUNT_PROPAGATE) > - propagate_umount(&tmp_list); > - > - while (!list_empty(&tmp_list)) { > - struct mnt_namespace *ns; > - bool disconnect; > - p = list_first_entry(&tmp_list, struct mount, mnt_list); > - list_del_init(&p->mnt_expire); > - list_del_init(&p->mnt_list); > - ns = p->mnt_ns; > - if (ns) { > - ns->mounts--; > - __touch_mnt_namespace(ns); > - } > - p->mnt_ns = NULL; > - if (how & UMOUNT_SYNC) > - p->mnt.mnt_flags |= MNT_SYNC_UMOUNT; > - > - disconnect = disconnect_mount(p, how); > - > - pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt, > -  disconnect ? &unmounted : NULL); > - if (mnt_has_parent(p)) { > - mnt_add_count(p->mnt_parent, -1); > - if (!disconnect) { > - /* Don't forget about p */ > - list_add_tail(&p->mnt_child, &p->mnt_parent- > >mnt_mounts); > - } else { > - umount_mnt(p); > + /* Add propogated mounts to the tmp_list */ > + if (how & UMOUNT_PROPAGATE) > + propagate_umount(&tmp_list); > + > + if (p == mnt) > + done = 1; > + > + while (!list_empty(&tmp_list)) { > + struct mnt_namespace *ns; > + bool disconnect; > + p = list_first_entry(&tmp_list, struct mount, > mnt_list); > + list_del_init(&p->mnt_expire); > + list_del_init(&p->mnt_list); > + ns = p->mnt_ns; > + if (ns) { > + ns->mounts--; > + __touch_mnt_namespace(ns); > + } > + p->mnt_ns = NULL; > + if (how & UMOUNT_SYNC) > + p->mnt.mnt_flags |= MNT_SYNC_UMOUNT; > + > + disconnect = disconnect_mount(p, how); > + > + pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt, > +  disconnect ? &unmounted : NULL); > + if (mnt_has_parent(p)) { > + mnt_add_count(p->mnt_parent, -1); > + if (!disconnect) { > + /* Don't forget about p */ > + list_add_tail(&p->mnt_child, &p- > >mnt_parent->mnt_mounts); > + } else { > + umount_mnt(p); > + } >   } > + change_mnt_propagation(p, MS_PRIVATE); >   } > - change_mnt_propagation(p, MS_PRIVATE); >   } >  } >