From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jeff Layton Subject: Re: [PATCH v23 16/22] richacl: Create-time inheritance Date: Tue, 12 Jul 2016 07:41:55 -0400 Message-ID: <1468323715.7798.10.camel@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-17-git-send-email-agruenba@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: "J. Bruce Fields" , linux-nfs@vger.kernel.org, Theodore Ts'o , linux-cifs@vger.kernel.org, linux-api@vger.kernel.org, Trond Myklebust , linux-kernel@vger.kernel.org, xfs@oss.sgi.com, Christoph Hellwig , Andreas Dilger , linux-fsdevel@vger.kernel.org, linux-ext4@vger.kernel.org, Anna Schumaker To: Andreas Gruenbacher , Alexander Viro Return-path: In-Reply-To: <1467294433-3222-17-git-send-email-agruenba@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: xfs-bounces@oss.sgi.com Sender: xfs-bounces@oss.sgi.com List-Id: linux-cifs.vger.kernel.org T24gVGh1LCAyMDE2LTA2LTMwIGF0IDE1OjQ3ICswMjAwLCBBbmRyZWFzIEdydWVuYmFjaGVyIHdy b3RlOgo+IFdoZW4gYSBuZXcgZmlsZSBpcyBjcmVhdGVkLCBpdCBjYW4gaW5oZXJpdCBhbiBhY2wg ZnJvbSBpdHMgcGFyZW50Cj4gZGlyZWN0b3J5OyB0aGlzIGlzIHNpbWlsYXIgdG8gaG93IGRlZmF1 bHQgYWNscyB3b3JrIGluIFBPU0lYIEFDTHMuCj4gCj4gQXMgd2l0aCBQT1NJWCBBQ0xzLCBpZiBh IGZpbGUgaW5oZXJpdHMgYW4gYWNsIGZyb20gaXRzIHBhcmVudCBkaXJlY3RvcnksCj4gdGhlIGlu dGVyc2VjdGlvbiBiZXR3ZWVuIHRoZSBjcmVhdGUgbW9kZSBhbmQgdGhlIHBlcm1pc3Npb25zIGdy YW50ZWQgYnkKPiB0aGUgaW5oZXJpdGVkIGFjbCBkZXRlcm1pbmVzIHRoZSBmaWxlIG1hc2tzIGFu ZCBmaWxlIHBlcm1pc3Npb24gYml0cywKPiBhbmQgdGhlIHVtYXNrIGlzIGlnbm9yZWQuCj4gCj4g U2lnbmVkLW9mZi1ieTogQW5kcmVhcyBHcnVlbmJhY2hlciA8YWdydWVuYmFAcmVkaGF0LmNvbT4K PiAtLS0KPiDCoGZzL3JpY2hhY2wuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHwgMTUxICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+IMKgaW5jbHVkZS9s aW51eC9yaWNoYWNsLmggfMKgwqDCoDIgKwo+IMKgMiBmaWxlcyBjaGFuZ2VkLCAxNTMgaW5zZXJ0 aW9ucygrKQo+IAo+IGRpZmYgLS1naXQgYS9mcy9yaWNoYWNsLmMgYi9mcy9yaWNoYWNsLmMKPiBp bmRleCBlOGEzODNiLi4yOWVhZjg5IDEwMDY0NAo+IC0tLSBhL2ZzL3JpY2hhY2wuYwo+ICsrKyBi L2ZzL3JpY2hhY2wuYwo+IEBAIC03MjIsMyArNzIyLDE1NCBAQCByaWNoYWNsX2VxdWl2X21vZGUo Y29uc3Qgc3RydWN0IHJpY2hhY2wgKmFjbCwgdW1vZGVfdCAqbW9kZV9wKQo+IMKgCXJldHVybiAw Owo+IMKgfQo+IMKgRVhQT1JUX1NZTUJPTF9HUEwocmljaGFjbF9lcXVpdl9tb2RlKTsKPiArCj4g K3N0YXRpYyBpbmxpbmUgYm9vbAo+ICthY2VfaW5oZXJpdHNfdG9fZGlyZWN0b3J5KGNvbnN0IHN0 cnVjdCByaWNoYWNlICphY2UpCj4gK3sKPiArCWlmIChhY2UtPmVfZmxhZ3MgJiBSSUNIQUNFX0RJ UkVDVE9SWV9JTkhFUklUX0FDRSkKPiArCQlyZXR1cm4gdHJ1ZTsKPiArCWlmICgoYWNlLT5lX2Zs YWdzICYgUklDSEFDRV9GSUxFX0lOSEVSSVRfQUNFKSAmJgo+ICsJwqDCoMKgwqAhKGFjZS0+ZV9m bGFncyAmIFJJQ0hBQ0VfTk9fUFJPUEFHQVRFX0lOSEVSSVRfQUNFKSkKPiArCQlyZXR1cm4gdHJ1 ZTsKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArLyoqCj4gKyAqIHJpY2hhY2xfaW5oZXJp dMKgwqAtwqDCoGNvbXB1dGUgdGhlIGluaGVyaXRlZCBhY2wgb2YgYSBuZXcgZmlsZQo+ICsgKiBA ZGlyX2FjbDoJYWNsIG9mIHRoZSBjb250YWluaW5nIGRpcmVjdG9yeQo+ICsgKiBAaXNkaXI6CWlu aGVyaXQgYnkgYSBkaXJlY3Rvcnkgb3Igbm9uLWRpcmVjdG9yeT8KPiArICoKPiArICogQSBkaXJl Y3RvcnkgY2FuIGhhdmUgYWNsIGVudHJpZXMgd2hpY2ggZmlsZXMgYW5kL29yIGRpcmVjdG9yaWVz IGNyZWF0ZWQKPiArICogaW5zaWRlIHRoZSBkaXJlY3Rvcnkgd2lsbCBpbmhlcml0LsKgwqBUaGlz IGZ1bmN0aW9uIGNvbXB1dGVzIHRoZSBhY2wgZm9yIHN1Y2gKPiArICogYSBuZXcgZmlsZS7CoMKg SWYgdGhlcmUgaXMgbm8gaW5oZXJpdGFibGUgYWNsLCBpdCB3aWxsIHJldHVybiAlTlVMTC4KPiAr ICovCj4gK3N0cnVjdCByaWNoYWNsICoKPiArcmljaGFjbF9pbmhlcml0KGNvbnN0IHN0cnVjdCBy aWNoYWNsICpkaXJfYWNsLCBpbnQgaXNkaXIpCj4gK3sKPiArCWNvbnN0IHN0cnVjdCByaWNoYWNl ICpkaXJfYWNlOwo+ICsJc3RydWN0IHJpY2hhY2wgKmFjbCA9IE5VTEw7Cj4gKwlzdHJ1Y3Qgcmlj aGFjZSAqYWNlOwo+ICsJaW50IGNvdW50ID0gMDsKPiArCj4gKwlpZiAoaXNkaXIpIHsKPiArCQly aWNoYWNsX2Zvcl9lYWNoX2VudHJ5KGRpcl9hY2UsIGRpcl9hY2wpIHsKPiArCQkJaWYgKCFhY2Vf aW5oZXJpdHNfdG9fZGlyZWN0b3J5KGRpcl9hY2UpKQo+ICsJCQkJY29udGludWU7Cj4gKwkJCWNv dW50Kys7Cj4gKwkJfQo+ICsJCWlmICghY291bnQpCj4gKwkJCXJldHVybiBOVUxMOwo+ICsJCWFj bCA9IHJpY2hhY2xfYWxsb2MoY291bnQsIEdGUF9LRVJORUwpOwo+ICsJCWlmICghYWNsKQo+ICsJ CQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKPiArCQlhY2UgPSBhY2wtPmFfZW50cmllczsKPiAr CQlyaWNoYWNsX2Zvcl9lYWNoX2VudHJ5KGRpcl9hY2UsIGRpcl9hY2wpIHsKPiArCQkJaWYgKCFh Y2VfaW5oZXJpdHNfdG9fZGlyZWN0b3J5KGRpcl9hY2UpKQo+ICsJCQkJY29udGludWU7Cj4gKwkJ CXJpY2hhY2VfY29weShhY2UsIGRpcl9hY2UpOwo+ICsJCQlpZiAoZGlyX2FjZS0+ZV9mbGFncyAm IFJJQ0hBQ0VfTk9fUFJPUEFHQVRFX0lOSEVSSVRfQUNFKQo+ICsJCQkJYWNlLT5lX2ZsYWdzICY9 IH5SSUNIQUNFX0lOSEVSSVRBTkNFX0ZMQUdTOwo+ICsJCQllbHNlIGlmIChkaXJfYWNlLT5lX2Zs YWdzICYgUklDSEFDRV9ESVJFQ1RPUllfSU5IRVJJVF9BQ0UpCj4gKwkJCQlhY2UtPmVfZmxhZ3Mg Jj0gflJJQ0hBQ0VfSU5IRVJJVF9PTkxZX0FDRTsKPiArCQkJZWxzZQo+ICsJCQkJYWNlLT5lX2Zs YWdzIHw9IFJJQ0hBQ0VfSU5IRVJJVF9PTkxZX0FDRTsKPiArCQkJYWNlKys7Cj4gKwkJfQo+ICsJ fSBlbHNlIHsKPiArCQlyaWNoYWNsX2Zvcl9lYWNoX2VudHJ5KGRpcl9hY2UsIGRpcl9hY2wpIHsK PiArCQkJaWYgKCEoZGlyX2FjZS0+ZV9mbGFncyAmIFJJQ0hBQ0VfRklMRV9JTkhFUklUX0FDRSkp Cj4gKwkJCQljb250aW51ZTsKPiArCQkJY291bnQrKzsKPiArCQl9Cj4gKwkJaWYgKCFjb3VudCkK PiArCQkJcmV0dXJuIE5VTEw7Cj4gKwkJYWNsID0gcmljaGFjbF9hbGxvYyhjb3VudCwgR0ZQX0tF Uk5FTCk7Cj4gKwkJaWYgKCFhY2wpCj4gKwkJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwo+ICsJ CWFjZSA9IGFjbC0+YV9lbnRyaWVzOwo+ICsJCXJpY2hhY2xfZm9yX2VhY2hfZW50cnkoZGlyX2Fj ZSwgZGlyX2FjbCkgewo+ICsJCQlpZiAoIShkaXJfYWNlLT5lX2ZsYWdzICYgUklDSEFDRV9GSUxF X0lOSEVSSVRfQUNFKSkKPiArCQkJCWNvbnRpbnVlOwo+ICsJCQlyaWNoYWNlX2NvcHkoYWNlLCBk aXJfYWNlKTsKPiArCQkJYWNlLT5lX2ZsYWdzICY9IH5SSUNIQUNFX0lOSEVSSVRBTkNFX0ZMQUdT Owo+ICsJCQkvKgo+ICsJCQnCoCogUklDSEFDRV9ERUxFVEVfQ0hJTEQgaXMgbWVhbmluZ2xlc3Mg Zm9yCj4gKwkJCcKgKiBub24tZGlyZWN0b3JpZXMsIHNvIGNsZWFyIGl0Lgo+ICsJCQnCoCovCj4g KwkJCWFjZS0+ZV9tYXNrICY9IH5SSUNIQUNFX0RFTEVURV9DSElMRDsKPiArCQkJYWNlKys7Cj4g KwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiBhY2w7Cj4gK30KPiArCj4gKy8qCj4gKyAqIHJpY2hh Y2xfaW5oZXJpdF9pbm9kZcKgwqAtwqDCoGNvbXB1dGUgaW5oZXJpdGVkIGFjbCBhbmQgZmlsZSBt b2RlCj4gKyAqIEBkaXJfYWNsOglhY2wgb2YgdGhlIGNvbnRhaW5pbmcgZGlyZWN0b3J5Cj4gKyAq IEBtb2RlX3A6CW1vZGUgb2YgdGhlIG5ldyBpbm9kZQo+ICsgKgo+ICsgKiBUaGUgZmlsZSBwZXJt aXNzaW9uIGJpdHMgaW4gQG1vZGVfcCBtdXN0IGJlIHNldCB0byB0aGUgY3JlYXRlIG1vZGUgYnkg dGhlCj4gKyAqIGNhbGxlci4KPiArICoKPiArICogSWYgdGhlcmUgaXMgYW4gaW5oZXJpdGFibGUg YWNsLCB0aGUgbWF4aW11bSBwZXJtaXNzaW9ucyB0aGF0IHRoZSBhY2wgZ3JhbnRzCj4gKyAqIGFy ZSBjb21wdXRlZCBhbmQgdGhlIGZpbGUgbWFza3Mgb2YgdGhlIG5ldyBhY2wgYXJlIHNldCBhY2Nv cmRpbmdseS4KPiArICovCj4gK3N0YXRpYyBzdHJ1Y3QgcmljaGFjbCAqCj4gK3JpY2hhY2xfaW5o ZXJpdF9pbm9kZShjb25zdCBzdHJ1Y3QgcmljaGFjbCAqZGlyX2FjbCwgdW1vZGVfdCAqbW9kZV9w KQo+ICt7Cj4gKwlzdHJ1Y3QgcmljaGFjbCAqYWNsOwo+ICsJdW1vZGVfdCBtb2RlID0gKm1vZGVf cDsKPiArCj4gKwlhY2wgPSByaWNoYWNsX2luaGVyaXQoZGlyX2FjbCwgU19JU0RJUihtb2RlKSk7 Cj4gKwlpZiAoYWNsKSB7Cj4gKwkJaWYgKHJpY2hhY2xfZXF1aXZfbW9kZShhY2wsICZtb2RlKSA9 PSAwKSB7Cj4gKwkJCSptb2RlX3AgJj0gbW9kZTsKPiArCQkJcmljaGFjbF9wdXQoYWNsKTsKPiAr CQkJYWNsID0gTlVMTDsKPiArCQl9IGVsc2Ugewo+ICsJCQlyaWNoYWNsX2NvbXB1dGVfbWF4X21h c2tzKGFjbCk7Cj4gKwkJCS8qCj4gKwkJCcKgKiBFbnN1cmUgdGhhdCB0aGUgYWNsIHdpbGwgbm90 IGdyYW50IGFueSBwZXJtaXNzaW9ucwo+ICsJCQnCoCogYmV5b25kIHRoZSBjcmVhdGUgbW9kZS4K PiArCQkJwqAqLwo+ICsJCQlhY2wtPmFfZmxhZ3MgfD0gUklDSEFDTF9NQVNLRUQ7Cj4gKwkJCWFj bC0+YV9vd25lcl9tYXNrICY9Cj4gKwkJCQlyaWNoYWNsX21vZGVfdG9fbWFzayhtb2RlID4+IDYp Owo+ICsJCQlhY2wtPmFfZ3JvdXBfbWFzayAmPQo+ICsJCQkJcmljaGFjbF9tb2RlX3RvX21hc2so bW9kZSA+PiAzKTsKPiArCQkJYWNsLT5hX290aGVyX21hc2sgJj0KPiArCQkJCXJpY2hhY2xfbW9k ZV90b19tYXNrKG1vZGUpOwo+ICsJCX0KPiArCX0gZWxzZQo+ICsJCSptb2RlX3AgJj0gfmN1cnJl bnRfdW1hc2soKTsKPiArCj4gKwlyZXR1cm4gYWNsOwo+ICt9Cj4gKwo+ICsvKioKPiArICogcmlj aGFjbF9jcmVhdGXCoMKgLcKgwqBmaWxlc3lzdGVtIGNyZWF0ZSBoZWxwZXIKPiArICogQG1vZGVf cDoJbW9kZSBvZiB0aGUgbmV3IGlub2RlCj4gKyAqIEBkaXI6CWNvbnRhaW5pbmcgZGlyZWN0b3J5 Cj4gKyAqCj4gKyAqIENvbXB1dGUgdGhlIGluaGVyaXRlZCBhY2wgZm9yIGEgbmV3IGlub2RlLsKg wqBJZiB0aGVyZSBpcyBubyBhY2wgdG8gaW5oZXJpdCwKPiArICogYXBwbHkgdGhlIHVtYXNrLsKg wqBVc2Ugd2hlbiBjcmVhdGluZyBhIG5ldyBpbm9kZSBvbiBhIHJpY2hhY2wgZW5hYmxlZCBmaWxl Cj4gKyAqIHN5c3RlbS4KPiArICovCj4gK3N0cnVjdCByaWNoYWNsICpyaWNoYWNsX2NyZWF0ZSh1 bW9kZV90ICptb2RlX3AsIHN0cnVjdCBpbm9kZSAqZGlyKQo+ICt7Cj4gKwlzdHJ1Y3QgcmljaGFj bCAqZGlyX2FjbCwgKmFjbCA9IE5VTEw7Cj4gKwo+ICsJaWYgKFNfSVNMTksoKm1vZGVfcCkpCj4g KwkJcmV0dXJuIE5VTEw7Cj4gKwlkaXJfYWNsID0gZ2V0X3JpY2hhY2woZGlyKTsKPiArCWlmIChk aXJfYWNsKSB7Cj4gKwkJaWYgKElTX0VSUihkaXJfYWNsKSkKPiArCQkJcmV0dXJuIGRpcl9hY2w7 Cj4gKwkJYWNsID0gcmljaGFjbF9pbmhlcml0X2lub2RlKGRpcl9hY2wsIG1vZGVfcCk7Cj4gKwkJ cmljaGFjbF9wdXQoZGlyX2FjbCk7Cj4gKwl9IGVsc2UKPiArCQkqbW9kZV9wICY9IH5jdXJyZW50 X3VtYXNrKCk7Cj4gKwlyZXR1cm4gYWNsOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHJpY2hh Y2xfY3JlYXRlKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9yaWNoYWNsLmggYi9pbmNs dWRlL2xpbnV4L3JpY2hhY2wuaAo+IGluZGV4IDkyMTJlZGIuLjdhY2ExYTMgMTAwNjQ0Cj4gLS0t IGEvaW5jbHVkZS9saW51eC9yaWNoYWNsLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L3JpY2hhY2wu aAo+IEBAIC0xOTIsNSArMTkyLDcgQEAgZXh0ZXJuIHZvaWQgcmljaGFjbF9jb21wdXRlX21heF9t YXNrcyhzdHJ1Y3QgcmljaGFjbCAqKTsKPiDCoGV4dGVybiBpbnQgcmljaGFjbF9wZXJtaXNzaW9u KHN0cnVjdCBpbm9kZSAqLCBjb25zdCBzdHJ1Y3QgcmljaGFjbCAqLCBpbnQpOwo+IMKgZXh0ZXJu IGludCByaWNoYWNsX2NobW9kKHN0cnVjdCBpbm9kZSAqLCB1bW9kZV90KTsKPiDCoGV4dGVybiBp bnQgcmljaGFjbF9lcXVpdl9tb2RlKGNvbnN0IHN0cnVjdCByaWNoYWNsICosIHVtb2RlX3QgKik7 Cj4gK2V4dGVybiBzdHJ1Y3QgcmljaGFjbCAqcmljaGFjbF9pbmhlcml0KGNvbnN0IHN0cnVjdCBy aWNoYWNsICosIGludCk7Cj4gK2V4dGVybiBzdHJ1Y3QgcmljaGFjbCAqcmljaGFjbF9jcmVhdGUo dW1vZGVfdCAqLCBzdHJ1Y3QgaW5vZGUgKik7Cj4gwqAKPiDCoCNlbmRpZiAvKiBfX1JJQ0hBQ0xf SCAqLwoKUmV2aWV3ZWQtYnk6IEplZmYgTGF5dG9uIDxqbGF5dG9uQHJlZGhhdC5jb20+CgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwp4ZnMgbWFpbGluZyBs aXN0Cnhmc0Bvc3Muc2dpLmNvbQpodHRwOi8vb3NzLnNnaS5jb20vbWFpbG1hbi9saXN0aW5mby94 ZnMK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933040AbcGLLmC (ORCPT ); Tue, 12 Jul 2016 07:42:02 -0400 Received: from mail-qk0-f174.google.com ([209.85.220.174]:33102 "EHLO mail-qk0-f174.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932622AbcGLLl7 (ORCPT ); Tue, 12 Jul 2016 07:41:59 -0400 Message-ID: <1468323715.7798.10.camel@redhat.com> Subject: Re: [PATCH v23 16/22] richacl: Create-time inheritance From: Jeff Layton To: Andreas Gruenbacher , Alexander Viro Cc: Christoph Hellwig , "Theodore Ts'o" , Andreas Dilger , "J. Bruce Fields" , Trond Myklebust , Anna Schumaker , Dave Chinner , linux-ext4@vger.kernel.org, xfs@oss.sgi.com, linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-nfs@vger.kernel.org, linux-cifs@vger.kernel.org, linux-api@vger.kernel.org Date: Tue, 12 Jul 2016 07:41:55 -0400 In-Reply-To: <1467294433-3222-17-git-send-email-agruenba@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-17-git-send-email-agruenba@redhat.com> Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.20.3 (3.20.3-1.fc24) Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, 2016-06-30 at 15:47 +0200, Andreas Gruenbacher wrote: > When a new file is created, it can inherit an acl from its parent > directory; this is similar to how default acls work in POSIX ACLs. > > As with POSIX ACLs, if a file inherits an acl from its parent directory, > the intersection between the create mode and the permissions granted by > the inherited acl determines the file masks and file permission bits, > and the umask is ignored. > > Signed-off-by: Andreas Gruenbacher > --- >  fs/richacl.c            | 151 ++++++++++++++++++++++++++++++++++++++++++++++++ >  include/linux/richacl.h |   2 + >  2 files changed, 153 insertions(+) > > diff --git a/fs/richacl.c b/fs/richacl.c > index e8a383b..29eaf89 100644 > --- a/fs/richacl.c > +++ b/fs/richacl.c > @@ -722,3 +722,154 @@ richacl_equiv_mode(const struct richacl *acl, umode_t *mode_p) >   return 0; >  } >  EXPORT_SYMBOL_GPL(richacl_equiv_mode); > + > +static inline bool > +ace_inherits_to_directory(const struct richace *ace) > +{ > + if (ace->e_flags & RICHACE_DIRECTORY_INHERIT_ACE) > + return true; > + if ((ace->e_flags & RICHACE_FILE_INHERIT_ACE) && > +     !(ace->e_flags & RICHACE_NO_PROPAGATE_INHERIT_ACE)) > + return true; > + return false; > +} > + > +/** > + * richacl_inherit  -  compute the inherited acl of a new file > + * @dir_acl: acl of the containing directory > + * @isdir: inherit by a directory or non-directory? > + * > + * A directory can have acl entries which files and/or directories created > + * inside the directory will inherit.  This function computes the acl for such > + * a new file.  If there is no inheritable acl, it will return %NULL. > + */ > +struct richacl * > +richacl_inherit(const struct richacl *dir_acl, int isdir) > +{ > + const struct richace *dir_ace; > + struct richacl *acl = NULL; > + struct richace *ace; > + int count = 0; > + > + if (isdir) { > + richacl_for_each_entry(dir_ace, dir_acl) { > + if (!ace_inherits_to_directory(dir_ace)) > + continue; > + count++; > + } > + if (!count) > + return NULL; > + acl = richacl_alloc(count, GFP_KERNEL); > + if (!acl) > + return ERR_PTR(-ENOMEM); > + ace = acl->a_entries; > + richacl_for_each_entry(dir_ace, dir_acl) { > + if (!ace_inherits_to_directory(dir_ace)) > + continue; > + richace_copy(ace, dir_ace); > + if (dir_ace->e_flags & RICHACE_NO_PROPAGATE_INHERIT_ACE) > + ace->e_flags &= ~RICHACE_INHERITANCE_FLAGS; > + else if (dir_ace->e_flags & RICHACE_DIRECTORY_INHERIT_ACE) > + ace->e_flags &= ~RICHACE_INHERIT_ONLY_ACE; > + else > + ace->e_flags |= RICHACE_INHERIT_ONLY_ACE; > + ace++; > + } > + } else { > + richacl_for_each_entry(dir_ace, dir_acl) { > + if (!(dir_ace->e_flags & RICHACE_FILE_INHERIT_ACE)) > + continue; > + count++; > + } > + if (!count) > + return NULL; > + acl = richacl_alloc(count, GFP_KERNEL); > + if (!acl) > + return ERR_PTR(-ENOMEM); > + ace = acl->a_entries; > + richacl_for_each_entry(dir_ace, dir_acl) { > + if (!(dir_ace->e_flags & RICHACE_FILE_INHERIT_ACE)) > + continue; > + richace_copy(ace, dir_ace); > + ace->e_flags &= ~RICHACE_INHERITANCE_FLAGS; > + /* > +  * RICHACE_DELETE_CHILD is meaningless for > +  * non-directories, so clear it. > +  */ > + ace->e_mask &= ~RICHACE_DELETE_CHILD; > + ace++; > + } > + } > + > + return acl; > +} > + > +/* > + * richacl_inherit_inode  -  compute inherited acl and file mode > + * @dir_acl: acl of the containing directory > + * @mode_p: mode of the new inode > + * > + * The file permission bits in @mode_p must be set to the create mode by the > + * caller. > + * > + * If there is an inheritable acl, the maximum permissions that the acl grants > + * are computed and the file masks of the new acl are set accordingly. > + */ > +static struct richacl * > +richacl_inherit_inode(const struct richacl *dir_acl, umode_t *mode_p) > +{ > + struct richacl *acl; > + umode_t mode = *mode_p; > + > + acl = richacl_inherit(dir_acl, S_ISDIR(mode)); > + if (acl) { > + if (richacl_equiv_mode(acl, &mode) == 0) { > + *mode_p &= mode; > + richacl_put(acl); > + acl = NULL; > + } else { > + richacl_compute_max_masks(acl); > + /* > +  * Ensure that the acl will not grant any permissions > +  * beyond the create mode. > +  */ > + acl->a_flags |= RICHACL_MASKED; > + acl->a_owner_mask &= > + richacl_mode_to_mask(mode >> 6); > + acl->a_group_mask &= > + richacl_mode_to_mask(mode >> 3); > + acl->a_other_mask &= > + richacl_mode_to_mask(mode); > + } > + } else > + *mode_p &= ~current_umask(); > + > + return acl; > +} > + > +/** > + * richacl_create  -  filesystem create helper > + * @mode_p: mode of the new inode > + * @dir: containing directory > + * > + * Compute the inherited acl for a new inode.  If there is no acl to inherit, > + * apply the umask.  Use when creating a new inode on a richacl enabled file > + * system. > + */ > +struct richacl *richacl_create(umode_t *mode_p, struct inode *dir) > +{ > + struct richacl *dir_acl, *acl = NULL; > + > + if (S_ISLNK(*mode_p)) > + return NULL; > + dir_acl = get_richacl(dir); > + if (dir_acl) { > + if (IS_ERR(dir_acl)) > + return dir_acl; > + acl = richacl_inherit_inode(dir_acl, mode_p); > + richacl_put(dir_acl); > + } else > + *mode_p &= ~current_umask(); > + return acl; > +} > +EXPORT_SYMBOL_GPL(richacl_create); > diff --git a/include/linux/richacl.h b/include/linux/richacl.h > index 9212edb..7aca1a3 100644 > --- a/include/linux/richacl.h > +++ b/include/linux/richacl.h > @@ -192,5 +192,7 @@ extern void richacl_compute_max_masks(struct richacl *); >  extern int richacl_permission(struct inode *, const struct richacl *, int); >  extern int richacl_chmod(struct inode *, umode_t); >  extern int richacl_equiv_mode(const struct richacl *, umode_t *); > +extern struct richacl *richacl_inherit(const struct richacl *, int); > +extern struct richacl *richacl_create(umode_t *, struct inode *); >   >  #endif /* __RICHACL_H */ Reviewed-by: Jeff Layton