From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jeff Layton Subject: Re: [PATCH v23 18/22] richacl: xattr mapping functions Date: Tue, 12 Jul 2016 08:02:45 -0400 Message-ID: <1468324965.7798.17.camel@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-19-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-19-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+IE1hcCBiZXR3ZWVuICJzeXN0ZW0ucmljaGFjbCIgeGF0dHJzIGFuZCB0aGUgaW4ta2Vy bmVsIHJlcHJlc2VudGF0aW9uLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEFuZHJlYXMgR3J1ZW5iYWNo ZXIgPGFncnVlbmJhQHJlZGhhdC5jb20+Cj4gLS0tCj4gwqBmcy9NYWtlZmlsZcKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAyICstCj4gwqBmcy9y aWNoYWNsX3hhdHRyLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfCAxNjEgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+IMKgaW5jbHVkZS9saW51eC9yaWNo YWNsX3hhdHRyLmjCoMKgwqDCoMKgwqB8wqDCoDI5ICsrKysrKysKPiDCoGluY2x1ZGUvdWFwaS9s aW51eC9LYnVpbGTCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAxICsKPiDCoGluY2x1ZGUvdWFw aS9saW51eC9yaWNoYWNsX3hhdHRyLmggfMKgwqA0NCArKysrKysrKysrCj4gwqBpbmNsdWRlL3Vh cGkvbGludXgveGF0dHIuaMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAyICsKPiDCoDYgZmlsZXMg Y2hhbmdlZCwgMjM4IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiDCoGNyZWF0ZSBtb2Rl IDEwMDY0NCBmcy9yaWNoYWNsX3hhdHRyLmMKPiDCoGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRl L2xpbnV4L3JpY2hhY2xfeGF0dHIuaAo+IMKgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvdWFw aS9saW51eC9yaWNoYWNsX3hhdHRyLmgKPiAKPiBkaWZmIC0tZ2l0IGEvZnMvTWFrZWZpbGUgYi9m cy9NYWtlZmlsZQo+IGluZGV4IDJiM2U2ZjEuLjI2MmZkNjcgMTAwNjQ0Cj4gLS0tIGEvZnMvTWFr ZWZpbGUKPiArKysgYi9mcy9NYWtlZmlsZQo+IEBAIC00OSw3ICs0OSw3IEBAIG9iai0kKENPTkZJ R19DT1JFRFVNUCkJCSs9IGNvcmVkdW1wLm8KPiDCoG9iai0kKENPTkZJR19TWVNDVEwpCQkrPSBk cm9wX2NhY2hlcy5vCj4gwqAKPiDCoG9iai0kKENPTkZJR19GSEFORExFKQkJKz0gZmhhbmRsZS5v Cj4gLW9iai0kKENPTkZJR19GU19SSUNIQUNMKQkrPSByaWNoYWNsLm8KPiArb2JqLSQoQ09ORklH X0ZTX1JJQ0hBQ0wpCSs9IHJpY2hhY2wubyByaWNoYWNsX3hhdHRyLm8KPiDCoAo+IMKgb2JqLXkJ CQkJKz0gcXVvdGEvCj4gwqAKPiBkaWZmIC0tZ2l0IGEvZnMvcmljaGFjbF94YXR0ci5jIGIvZnMv cmljaGFjbF94YXR0ci5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi5k YzFhZDM2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2ZzL3JpY2hhY2xfeGF0dHIuYwo+IEBAIC0w LDAgKzEsMTYxIEBACj4gKy8qCj4gKyAqIENvcHlyaWdodCAoQykgMjAwNiwgMjAxMMKgwqBOb3Zl bGwsIEluYy4KPiArICogQ29weXJpZ2h0IChDKSAyMDE1wqDCoFJlZCBIYXQsIEluYy4KPiArICog V3JpdHRlbiBieSBBbmRyZWFzIEdydWVuYmFjaGVyIDxhZ3J1ZW5iYUByZWRoYXQuY29tPgo+ICsg Kgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yIG1vZGlmeSBpdAo+ICsgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKPiArICogRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pIGFu eQo+ICsgKiBsYXRlciB2ZXJzaW9uLgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0Cj4gKyAqIFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiAr ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLsKg wqBTZWUgdGhlIEdOVQo+ICsgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgCj4gKyNpbmNsdWRlIAo+ICsjaW5jbHVkZSAKPiAr I2luY2x1ZGUgCj4gKyNpbmNsdWRlIAo+ICsKPiArLyoqCj4gKyAqIHJpY2hhY2xfZnJvbV94YXR0 csKgwqAtwqDCoGNvbnZlcnQgYSByaWNoYWNsIHhhdHRyIGludG8gdGhlIGluLW1lbW9yeSByZXBy ZXNlbnRhdGlvbgo+ICsgKi8KPiArc3RydWN0IHJpY2hhY2wgKgo+ICtyaWNoYWNsX2Zyb21feGF0 dHIoc3RydWN0IHVzZXJfbmFtZXNwYWNlICp1c2VyX25zLAo+ICsJCcKgwqDCoGNvbnN0IHZvaWQg KnZhbHVlLCBzaXplX3Qgc2l6ZSwgaW50IGludmFsaWRfZXJyb3IpCj4gK3sKPiArCWNvbnN0IHN0 cnVjdCByaWNoYWNsX3hhdHRyICp4YXR0cl9hY2wgPSB2YWx1ZTsKPiArCWNvbnN0IHN0cnVjdCBy aWNoYWNlX3hhdHRyICp4YXR0cl9hY2UgPSAodm9pZCAqKSh4YXR0cl9hY2wgKyAxKTsKPiArCXN0 cnVjdCByaWNoYWNsICphY2w7Cj4gKwlzdHJ1Y3QgcmljaGFjZSAqYWNlOwo+ICsJaW50IGNvdW50 Owo+ICsKPiArCWlmIChzaXplIDwgc2l6ZW9mKCp4YXR0cl9hY2wpIHx8Cj4gKwnCoMKgwqDCoHhh dHRyX2FjbC0+YV92ZXJzaW9uICE9IFJJQ0hBQ0xfWEFUVFJfVkVSU0lPTiB8fAo+ICsJwqDCoMKg wqAoeGF0dHJfYWNsLT5hX2ZsYWdzICYgflJJQ0hBQ0xfVkFMSURfRkxBR1MpKQo+ICsJCWdvdG8g aW52YWxpZDsKPiArCXNpemUgLT0gc2l6ZW9mKCp4YXR0cl9hY2wpOwo+ICsJY291bnQgPSBsZTE2 X3RvX2NwdSh4YXR0cl9hY2wtPmFfY291bnQpOwo+ICsJaWYgKGNvdW50ID4gUklDSEFDTF9YQVRU Ul9NQVhfQ09VTlQpCj4gKwkJZ290byBpbnZhbGlkOwo+ICsJaWYgKHNpemUgIT0gY291bnQgKiBz aXplb2YoKnhhdHRyX2FjZSkpCj4gKwkJZ290byBpbnZhbGlkOwo+ICsKPiArCWFjbCA9IHJpY2hh Y2xfYWxsb2MoY291bnQsIEdGUF9OT0ZTKTsKPiArCWlmICghYWNsKQo+ICsJCXJldHVybiBFUlJf UFRSKC1FTk9NRU0pOwo+ICsKPiArCWFjbC0+YV9mbGFncyA9IHhhdHRyX2FjbC0+YV9mbGFnczsK PiArCWFjbC0+YV9vd25lcl9tYXNrID0gbGUzMl90b19jcHUoeGF0dHJfYWNsLT5hX293bmVyX21h c2spOwo+ICsJaWYgKGFjbC0+YV9vd25lcl9tYXNrICYgflJJQ0hBQ0VfVkFMSURfTUFTSykKPiAr CQlnb3RvIHB1dF9pbnZhbGlkOwo+ICsJYWNsLT5hX2dyb3VwX21hc2sgPSBsZTMyX3RvX2NwdSh4 YXR0cl9hY2wtPmFfZ3JvdXBfbWFzayk7Cj4gKwlpZiAoYWNsLT5hX2dyb3VwX21hc2sgJiB+UklD SEFDRV9WQUxJRF9NQVNLKQo+ICsJCWdvdG8gcHV0X2ludmFsaWQ7Cj4gKwlhY2wtPmFfb3RoZXJf bWFzayA9IGxlMzJfdG9fY3B1KHhhdHRyX2FjbC0+YV9vdGhlcl9tYXNrKTsKPiArCWlmIChhY2wt PmFfb3RoZXJfbWFzayAmIH5SSUNIQUNFX1ZBTElEX01BU0spCj4gKwkJZ290byBwdXRfaW52YWxp ZDsKPiArCj4gKwlyaWNoYWNsX2Zvcl9lYWNoX2VudHJ5KGFjZSwgYWNsKSB7Cj4gKwkJYWNlLT5l X3R5cGXCoMKgPSBsZTE2X3RvX2NwdSh4YXR0cl9hY2UtPmVfdHlwZSk7Cj4gKwkJYWNlLT5lX2Zs YWdzID0gbGUxNl90b19jcHUoeGF0dHJfYWNlLT5lX2ZsYWdzKTsKPiArCQlhY2UtPmVfbWFza8Kg wqA9IGxlMzJfdG9fY3B1KHhhdHRyX2FjZS0+ZV9tYXNrKTsKPiArCj4gKwkJaWYgKGFjZS0+ZV9m bGFncyAmIH5SSUNIQUNFX1ZBTElEX0ZMQUdTKQo+ICsJCQlnb3RvIHB1dF9pbnZhbGlkOwo+ICsJ CWlmIChhY2UtPmVfZmxhZ3MgJiBSSUNIQUNFX1NQRUNJQUxfV0hPKSB7Cj4gKwkJCWFjZS0+ZV9p ZC5zcGVjaWFsID0gbGUzMl90b19jcHUoeGF0dHJfYWNlLT5lX2lkKTsKPiArCQkJaWYgKGFjZS0+ ZV9pZC5zcGVjaWFsID4gUklDSEFDRV9FVkVSWU9ORV9TUEVDSUFMX0lEKQo+ICsJCQkJZ290byBw dXRfaW52YWxpZDsKPiArCQl9IGVsc2UgaWYgKGFjZS0+ZV9mbGFncyAmIFJJQ0hBQ0VfSURFTlRJ RklFUl9HUk9VUCkgewo+ICsJCQl1MzIgaWQgPSBsZTMyX3RvX2NwdSh4YXR0cl9hY2UtPmVfaWQp Owo+ICsKPiArCQkJYWNlLT5lX2lkLmdpZCA9IG1ha2Vfa2dpZCh1c2VyX25zLCBpZCk7Cj4gKwkJ CWlmICghZ2lkX3ZhbGlkKGFjZS0+ZV9pZC5naWQpKQo+ICsJCQkJZ290byBwdXRfaW52YWxpZDsK PiArCQl9IGVsc2Ugewo+ICsJCQl1MzIgaWQgPSBsZTMyX3RvX2NwdSh4YXR0cl9hY2UtPmVfaWQp Owo+ICsKPiArCQkJYWNlLT5lX2lkLnVpZCA9IG1ha2Vfa3VpZCh1c2VyX25zLCBpZCk7Cj4gKwkJ CWlmICghdWlkX3ZhbGlkKGFjZS0+ZV9pZC51aWQpKQo+ICsJCQkJZ290byBwdXRfaW52YWxpZDsK PiArCQl9Cj4gKwkJaWYgKGFjZS0+ZV90eXBlID4gUklDSEFDRV9BQ0NFU1NfREVOSUVEX0FDRV9U WVBFIHx8Cj4gKwkJwqDCoMKgwqAoYWNlLT5lX21hc2sgJiB+UklDSEFDRV9WQUxJRF9NQVNLKSkK PiArCQkJZ290byBwdXRfaW52YWxpZDsKPiArCj4gKwkJeGF0dHJfYWNlKys7Cj4gKwl9Cj4gKwo+ ICsJcmV0dXJuIGFjbDsKPiArCj4gK3B1dF9pbnZhbGlkOgo+ICsJcmljaGFjbF9wdXQoYWNsKTsK PiAraW52YWxpZDoKPiArCXJldHVybiBFUlJfUFRSKGludmFsaWRfZXJyb3IpOwo+ICt9Cj4gK0VY UE9SVF9TWU1CT0xfR1BMKHJpY2hhY2xfZnJvbV94YXR0cik7Cj4gKwo+ICsvKioKPiArICogcmlj aGFjbF94YXR0cl9zaXplwqDCoC3CoMKgY29tcHV0ZSB0aGUgc2l6ZSBvZiB0aGUgeGF0dHIgcmVw cmVzZW50YXRpb24gb2YgQGFjbAo+ICsgKi8KPiArc2l6ZV90Cj4gK3JpY2hhY2xfeGF0dHJfc2l6 ZShjb25zdCBzdHJ1Y3QgcmljaGFjbCAqYWNsKQo+ICt7Cj4gKwlzaXplX3Qgc2l6ZSA9IHNpemVv ZihzdHJ1Y3QgcmljaGFjbF94YXR0cik7Cj4gKwo+ICsJc2l6ZSArPSBzaXplb2Yoc3RydWN0IHJp Y2hhY2VfeGF0dHIpICogYWNsLT5hX2NvdW50Owo+ICsJcmV0dXJuIHNpemU7Cj4gK30KPiArRVhQ T1JUX1NZTUJPTF9HUEwocmljaGFjbF94YXR0cl9zaXplKTsKPiArCj4gKy8qKgo+ICsgKiByaWNo YWNsX3RvX3hhdHRywqDCoC3CoMKgY29udmVydCBAYWNsIGludG8gaXRzIHhhdHRyIHJlcHJlc2Vu dGF0aW9uCj4gKyAqIEBhY2w6CXRoZSByaWNoYWNsIHRvIGNvbnZlcnQKPiArICogQGJ1ZmZlcjoJ YnVmZmVyIGZvciB0aGUgcmVzdWx0Cj4gKyAqIEBzaXplOglzaXplIG9mIEBidWZmZXIKPiArICov Cj4gK2ludAo+ICtyaWNoYWNsX3RvX3hhdHRyKHN0cnVjdCB1c2VyX25hbWVzcGFjZSAqdXNlcl9u cywKPiArCQnCoGNvbnN0IHN0cnVjdCByaWNoYWNsICphY2wsIHZvaWQgKmJ1ZmZlciwgc2l6ZV90 IHNpemUpCj4gK3sKPiArCXN0cnVjdCByaWNoYWNsX3hhdHRyICp4YXR0cl9hY2wgPSBidWZmZXI7 Cj4gKwlzdHJ1Y3QgcmljaGFjZV94YXR0ciAqeGF0dHJfYWNlOwo+ICsJY29uc3Qgc3RydWN0IHJp Y2hhY2UgKmFjZTsKPiArCXNpemVfdCByZWFsX3NpemU7Cj4gKwo+ICsJcmVhbF9zaXplID0gcmlj aGFjbF94YXR0cl9zaXplKGFjbCk7Cj4gKwlpZiAoIWJ1ZmZlcikKPiArCQlyZXR1cm4gcmVhbF9z aXplOwo+ICsJaWYgKHJlYWxfc2l6ZSA+IHNpemUpCj4gKwkJcmV0dXJuIC1FUkFOR0U7Cj4gKwo+ ICsJeGF0dHJfYWNsLT5hX3ZlcnNpb24gPSBSSUNIQUNMX1hBVFRSX1ZFUlNJT047Cj4gKwl4YXR0 cl9hY2wtPmFfZmxhZ3MgPSBhY2wtPmFfZmxhZ3M7Cj4gKwl4YXR0cl9hY2wtPmFfY291bnQgPSBj cHVfdG9fbGUxNihhY2wtPmFfY291bnQpOwo+ICsKPiArCXhhdHRyX2FjbC0+YV9vd25lcl9tYXNr ID0gY3B1X3RvX2xlMzIoYWNsLT5hX293bmVyX21hc2spOwo+ICsJeGF0dHJfYWNsLT5hX2dyb3Vw X21hc2sgPSBjcHVfdG9fbGUzMihhY2wtPmFfZ3JvdXBfbWFzayk7Cj4gKwl4YXR0cl9hY2wtPmFf b3RoZXJfbWFzayA9IGNwdV90b19sZTMyKGFjbC0+YV9vdGhlcl9tYXNrKTsKPiArCj4gKwl4YXR0 cl9hY2UgPSAodm9pZCAqKSh4YXR0cl9hY2wgKyAxKTsKPiArCXJpY2hhY2xfZm9yX2VhY2hfZW50 cnkoYWNlLCBhY2wpIHsKPiArCQl4YXR0cl9hY2UtPmVfdHlwZSA9IGNwdV90b19sZTE2KGFjZS0+ ZV90eXBlKTsKPiArCQl4YXR0cl9hY2UtPmVfZmxhZ3MgPSBjcHVfdG9fbGUxNihhY2UtPmVfZmxh Z3MpOwo+ICsJCXhhdHRyX2FjZS0+ZV9tYXNrID0gY3B1X3RvX2xlMzIoYWNlLT5lX21hc2spOwo+ ICsJCWlmIChhY2UtPmVfZmxhZ3MgJiBSSUNIQUNFX1NQRUNJQUxfV0hPKQo+ICsJCQl4YXR0cl9h Y2UtPmVfaWQgPSBjcHVfdG9fbGUzMihhY2UtPmVfaWQuc3BlY2lhbCk7Cj4gKwkJZWxzZSBpZiAo YWNlLT5lX2ZsYWdzICYgUklDSEFDRV9JREVOVElGSUVSX0dST1VQKQo+ICsJCQl4YXR0cl9hY2Ut PmVfaWQgPQo+ICsJCQkJY3B1X3RvX2xlMzIoZnJvbV9rZ2lkKHVzZXJfbnMsIGFjZS0+ZV9pZC5n aWQpKTsKPiArCQllbHNlCj4gKwkJCXhhdHRyX2FjZS0+ZV9pZCA9Cj4gKwkJCQljcHVfdG9fbGUz Mihmcm9tX2t1aWQodXNlcl9ucywgYWNlLT5lX2lkLnVpZCkpOwo+ICsJCXhhdHRyX2FjZSsrOwo+ ICsJfQo+ICsJcmV0dXJuIHJlYWxfc2l6ZTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChyaWNo YWNsX3RvX3hhdHRyKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9yaWNoYWNsX3hhdHRy LmggYi9pbmNsdWRlL2xpbnV4L3JpY2hhY2xfeGF0dHIuaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0 Cj4gaW5kZXggMDAwMDAwMC4uMGVmYTE0Ygo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRl L2xpbnV4L3JpY2hhY2xfeGF0dHIuaAo+IEBAIC0wLDAgKzEsMjkgQEAKPiArLyoKPiArICogQ29w eXJpZ2h0IChDKSAyMDA2LCAyMDEwwqDCoE5vdmVsbCwgSW5jLgo+ICsgKiBDb3B5cmlnaHQgKEMp IDIwMTXCoMKgUmVkIEhhdCwgSW5jLgo+ICsgKiBXcml0dGVuIGJ5IEFuZHJlYXMgR3J1ZW5iYWNo ZXIgPGFncnVlbmJhQHJlZGhhdC5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Cj4gKyAq IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVi bGlzaGVkIGJ5IHRoZQo+ICsgKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJz aW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55Cj4gKyAqIGxhdGVyIHZlcnNpb24uCj4gKyAq Cj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLCBidXQKPiArICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuwqDCoFNlZSB0aGUgR05VCj4gKyAqIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9f UklDSEFDTF9YQVRUUl9ICj4gKyNkZWZpbmUgX19SSUNIQUNMX1hBVFRSX0gKPiArCj4gKyNpbmNs dWRlIAo+ICsjaW5jbHVkZSAKPiArCj4gK2V4dGVybiBzdHJ1Y3QgcmljaGFjbCAqcmljaGFjbF9m cm9tX3hhdHRyKHN0cnVjdCB1c2VyX25hbWVzcGFjZSAqLCBjb25zdCB2b2lkICosCj4gKwkJCQkJ wqDCoHNpemVfdCwgaW50KTsKPiArZXh0ZXJuIHNpemVfdCByaWNoYWNsX3hhdHRyX3NpemUoY29u c3Qgc3RydWN0IHJpY2hhY2wgKik7Cj4gK2V4dGVybiBpbnQgcmljaGFjbF90b194YXR0cihzdHJ1 Y3QgdXNlcl9uYW1lc3BhY2UgKiwgY29uc3Qgc3RydWN0IHJpY2hhY2wgKiwKPiArCQkJwqDCoMKg wqB2b2lkICosIHNpemVfdCk7Cj4gKwo+ICsjZW5kaWYgLyogX19SSUNIQUNMX1hBVFRSX0ggKi8K PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L0tidWlsZCBiL2luY2x1ZGUvdWFwaS9s aW51eC9LYnVpbGQKPiBpbmRleCBhYmVhYTk4Li5jMjRlMTA2IDEwMDY0NAo+IC0tLSBhL2luY2x1 ZGUvdWFwaS9saW51eC9LYnVpbGQKPiArKysgYi9pbmNsdWRlL3VhcGkvbGludXgvS2J1aWxkCj4g QEAgLTM1Niw2ICszNTYsNyBAQCBoZWFkZXIteSArPSByZWlzZXJmc19mcy5oCj4gwqBoZWFkZXIt eSArPSByZWlzZXJmc194YXR0ci5oCj4gwqBoZWFkZXIteSArPSByZXNvdXJjZS5oCj4gwqBoZWFk ZXIteSArPSByaWNoYWNsLmgKPiAraGVhZGVyLXkgKz0gcmljaGFjbF94YXR0ci5oCj4gwqBoZWFk ZXIteSArPSByZmtpbGwuaAo+IMKgaGVhZGVyLXkgKz0gcmlvX21wb3J0X2NkZXYuaAo+IMKgaGVh ZGVyLXkgKz0gcm9tZnNfZnMuaAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvcmlj aGFjbF94YXR0ci5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L3JpY2hhY2xfeGF0dHIuaAo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uMjBkYTIwNAo+IC0tLSAvZGV2L251bGwK PiArKysgYi9pbmNsdWRlL3VhcGkvbGludXgvcmljaGFjbF94YXR0ci5oCj4gQEAgLTAsMCArMSw0 NCBAQAo+ICsvKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMDYsIDIwMTDCoMKgTm92ZWxsLCBJbmMu Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxNcKgwqBSZWQgSGF0LCBJbmMuCj4gKyAqIFdyaXR0ZW4g YnkgQW5kcmVhcyBHcnVlbmJhY2hlciA8YWdydWVuYmFAcmVkaGF0LmNvbT4KPiArICoKPiArICog VGhpcyBmaWxlIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgo+ICsgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVy YWwgUHVibGljCj4gKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlcgo+ICsgKiB2ZXJzaW9uIDIuMSBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KPiArICoKPiArICogVGhpcyBmaWxl IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCj4gKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS7CoMKgU2VlIHRoZSBHTlUKPiArICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9fVUFQSV9SSUNIQUNM X1hBVFRSX0gKPiArI2RlZmluZSBfX1VBUElfUklDSEFDTF9YQVRUUl9ICj4gKwo+ICsjaW5jbHVk ZSAKPiArI2luY2x1ZGUgCj4gKwo+ICtzdHJ1Y3QgcmljaGFjZV94YXR0ciB7Cj4gKwlfX2xlMTYJ ZV90eXBlOwo+ICsJX19sZTE2CWVfZmxhZ3M7Cj4gKwlfX2xlMzIJZV9tYXNrOwo+ICsJX19sZTMy CWVfaWQ7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgcmljaGFjbF94YXR0ciB7Cj4gKwlfX3U4CWFfdmVy c2lvbjsKPiArCV9fdTgJYV9mbGFnczsKPiArCV9fbGUxNglhX2NvdW50Owo+ICsJX19sZTMyCWFf b3duZXJfbWFzazsKPiArCV9fbGUzMglhX2dyb3VwX21hc2s7Cj4gKwlfX2xlMzIJYV9vdGhlcl9t YXNrOwo+ICt9Owo+ICsKPiArI2RlZmluZSBSSUNIQUNMX1hBVFRSX1ZFUlNJT04gMAo+ICsjZGVm aW5lIFJJQ0hBQ0xfWEFUVFJfTUFYX0NPVU5UIFwKPiArCSgoWEFUVFJfU0laRV9NQVggLSBzaXpl b2Yoc3RydWN0IHJpY2hhY2xfeGF0dHIpKSAvIFwKPiArCcKgc2l6ZW9mKHN0cnVjdCByaWNoYWNl X3hhdHRyKSkKPiArCj4gKyNlbmRpZsKgwqAvKiBfX1VBUElfUklDSEFDTF9YQVRUUl9IICovCj4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC94YXR0ci5oIGIvaW5jbHVkZS91YXBpL2xp bnV4L3hhdHRyLmgKPiBpbmRleCAxNTkwYzQ5Li4xOTk2OTAzIDEwMDY0NAo+IC0tLSBhL2luY2x1 ZGUvdWFwaS9saW51eC94YXR0ci5oCj4gKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3hhdHRyLmgK PiBAQCAtNzMsNSArNzMsNyBAQAo+IMKgI2RlZmluZSBYQVRUUl9QT1NJWF9BQ0xfREVGQVVMVMKg wqAicG9zaXhfYWNsX2RlZmF1bHQiCj4gwqAjZGVmaW5lIFhBVFRSX05BTUVfUE9TSVhfQUNMX0RF RkFVTFQgWEFUVFJfU1lTVEVNX1BSRUZJWCBYQVRUUl9QT1NJWF9BQ0xfREVGQVVMVAo+IMKgCj4g KyNkZWZpbmUgWEFUVFJfUklDSEFDTCAicmljaGFjbCIKPiArI2RlZmluZSBYQVRUUl9OQU1FX1JJ Q0hBQ0wgWEFUVFJfU1lTVEVNX1BSRUZJWCBYQVRUUl9SSUNIQUNMCj4gwqAKPiDCoCNlbmRpZiAv KiBfVUFQSV9MSU5VWF9YQVRUUl9IICovCgpGYWlyIGVub3VnaC4gSSBkbyB3b25kZXIgYSBiaXQg d2hldGhlciB3ZSBtaWdodCBiZSBiZXR0ZXIgc2VydmVkIHdpdGggYQpuZXcgc2V0IG9mIHN5c2Nh bGxzIGZvciB0aGlzIGluc3RlYWQgb2YgdXNpbmcgeGF0dHJzIChhcyBJIHRoaW5rCkNocmlzdG9w aCBoYXMgc3VnZ2VzdGVkKS4gV2hhdCBfaXNfIHRoZSByYXRpb25hbGUgZm9yIGRvaW5nIHRoaXMg d2l0aAp4YXR0cnMsIGJ0dz8KClJlZ2FyZGxlc3MsIHRoaXMgcGF0Y2ggbG9va3MgZmluZSB0byBt ZSwgYXNzdW1pbmcgdGhhdCB3ZSByZWFsbHkgZG8Kd2FudCB0byBkbyB0aGlzIHhhdHRyczoKClJl dmlld2VkLWJ5OiBKZWZmIExheXRvbiA8amxheXRvbkByZWRoYXQuY29tPgoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KeGZzIG1haWxpbmcgbGlzdAp4ZnNA b3NzLnNnaS5jb20KaHR0cDovL29zcy5zZ2kuY29tL21haWxtYW4vbGlzdGluZm8veGZzCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932935AbcGLMCy (ORCPT ); Tue, 12 Jul 2016 08:02:54 -0400 Received: from mail-qt0-f173.google.com ([209.85.216.173]:33536 "EHLO mail-qt0-f173.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753209AbcGLMCt (ORCPT ); Tue, 12 Jul 2016 08:02:49 -0400 Message-ID: <1468324965.7798.17.camel@redhat.com> Subject: Re: [PATCH v23 18/22] richacl: xattr mapping functions 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 08:02:45 -0400 In-Reply-To: <1467294433-3222-19-git-send-email-agruenba@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-19-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: > Map between "system.richacl" xattrs and the in-kernel representation. > > Signed-off-by: Andreas Gruenbacher > --- >  fs/Makefile                        |   2 +- >  fs/richacl_xattr.c                 | 161 +++++++++++++++++++++++++++++++++++++ >  include/linux/richacl_xattr.h      |  29 +++++++ >  include/uapi/linux/Kbuild          |   1 + >  include/uapi/linux/richacl_xattr.h |  44 ++++++++++ >  include/uapi/linux/xattr.h         |   2 + >  6 files changed, 238 insertions(+), 1 deletion(-) >  create mode 100644 fs/richacl_xattr.c >  create mode 100644 include/linux/richacl_xattr.h >  create mode 100644 include/uapi/linux/richacl_xattr.h > > diff --git a/fs/Makefile b/fs/Makefile > index 2b3e6f1..262fd67 100644 > --- a/fs/Makefile > +++ b/fs/Makefile > @@ -49,7 +49,7 @@ obj-$(CONFIG_COREDUMP) += coredump.o >  obj-$(CONFIG_SYSCTL) += drop_caches.o >   >  obj-$(CONFIG_FHANDLE) += fhandle.o > -obj-$(CONFIG_FS_RICHACL) += richacl.o > +obj-$(CONFIG_FS_RICHACL) += richacl.o richacl_xattr.o >   >  obj-y += quota/ >   > diff --git a/fs/richacl_xattr.c b/fs/richacl_xattr.c > new file mode 100644 > index 0000000..dc1ad36 > --- /dev/null > +++ b/fs/richacl_xattr.c > @@ -0,0 +1,161 @@ > +/* > + * Copyright (C) 2006, 2010  Novell, Inc. > + * Copyright (C) 2015  Red Hat, Inc. > + * Written by Andreas Gruenbacher > + * > + * 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; either version 2, or (at your option) any > + * later version. > + * > + * This program is distributed in the hope that it will be useful, but > + * WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU > + * General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +/** > + * richacl_from_xattr  -  convert a richacl xattr into the in-memory representation > + */ > +struct richacl * > +richacl_from_xattr(struct user_namespace *user_ns, > +    const void *value, size_t size, int invalid_error) > +{ > + const struct richacl_xattr *xattr_acl = value; > + const struct richace_xattr *xattr_ace = (void *)(xattr_acl + 1); > + struct richacl *acl; > + struct richace *ace; > + int count; > + > + if (size < sizeof(*xattr_acl) || > +     xattr_acl->a_version != RICHACL_XATTR_VERSION || > +     (xattr_acl->a_flags & ~RICHACL_VALID_FLAGS)) > + goto invalid; > + size -= sizeof(*xattr_acl); > + count = le16_to_cpu(xattr_acl->a_count); > + if (count > RICHACL_XATTR_MAX_COUNT) > + goto invalid; > + if (size != count * sizeof(*xattr_ace)) > + goto invalid; > + > + acl = richacl_alloc(count, GFP_NOFS); > + if (!acl) > + return ERR_PTR(-ENOMEM); > + > + acl->a_flags = xattr_acl->a_flags; > + acl->a_owner_mask = le32_to_cpu(xattr_acl->a_owner_mask); > + if (acl->a_owner_mask & ~RICHACE_VALID_MASK) > + goto put_invalid; > + acl->a_group_mask = le32_to_cpu(xattr_acl->a_group_mask); > + if (acl->a_group_mask & ~RICHACE_VALID_MASK) > + goto put_invalid; > + acl->a_other_mask = le32_to_cpu(xattr_acl->a_other_mask); > + if (acl->a_other_mask & ~RICHACE_VALID_MASK) > + goto put_invalid; > + > + richacl_for_each_entry(ace, acl) { > + ace->e_type  = le16_to_cpu(xattr_ace->e_type); > + ace->e_flags = le16_to_cpu(xattr_ace->e_flags); > + ace->e_mask  = le32_to_cpu(xattr_ace->e_mask); > + > + if (ace->e_flags & ~RICHACE_VALID_FLAGS) > + goto put_invalid; > + if (ace->e_flags & RICHACE_SPECIAL_WHO) { > + ace->e_id.special = le32_to_cpu(xattr_ace->e_id); > + if (ace->e_id.special > RICHACE_EVERYONE_SPECIAL_ID) > + goto put_invalid; > + } else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP) { > + u32 id = le32_to_cpu(xattr_ace->e_id); > + > + ace->e_id.gid = make_kgid(user_ns, id); > + if (!gid_valid(ace->e_id.gid)) > + goto put_invalid; > + } else { > + u32 id = le32_to_cpu(xattr_ace->e_id); > + > + ace->e_id.uid = make_kuid(user_ns, id); > + if (!uid_valid(ace->e_id.uid)) > + goto put_invalid; > + } > + if (ace->e_type > RICHACE_ACCESS_DENIED_ACE_TYPE || > +     (ace->e_mask & ~RICHACE_VALID_MASK)) > + goto put_invalid; > + > + xattr_ace++; > + } > + > + return acl; > + > +put_invalid: > + richacl_put(acl); > +invalid: > + return ERR_PTR(invalid_error); > +} > +EXPORT_SYMBOL_GPL(richacl_from_xattr); > + > +/** > + * richacl_xattr_size  -  compute the size of the xattr representation of @acl > + */ > +size_t > +richacl_xattr_size(const struct richacl *acl) > +{ > + size_t size = sizeof(struct richacl_xattr); > + > + size += sizeof(struct richace_xattr) * acl->a_count; > + return size; > +} > +EXPORT_SYMBOL_GPL(richacl_xattr_size); > + > +/** > + * richacl_to_xattr  -  convert @acl into its xattr representation > + * @acl: the richacl to convert > + * @buffer: buffer for the result > + * @size: size of @buffer > + */ > +int > +richacl_to_xattr(struct user_namespace *user_ns, > +  const struct richacl *acl, void *buffer, size_t size) > +{ > + struct richacl_xattr *xattr_acl = buffer; > + struct richace_xattr *xattr_ace; > + const struct richace *ace; > + size_t real_size; > + > + real_size = richacl_xattr_size(acl); > + if (!buffer) > + return real_size; > + if (real_size > size) > + return -ERANGE; > + > + xattr_acl->a_version = RICHACL_XATTR_VERSION; > + xattr_acl->a_flags = acl->a_flags; > + xattr_acl->a_count = cpu_to_le16(acl->a_count); > + > + xattr_acl->a_owner_mask = cpu_to_le32(acl->a_owner_mask); > + xattr_acl->a_group_mask = cpu_to_le32(acl->a_group_mask); > + xattr_acl->a_other_mask = cpu_to_le32(acl->a_other_mask); > + > + xattr_ace = (void *)(xattr_acl + 1); > + richacl_for_each_entry(ace, acl) { > + xattr_ace->e_type = cpu_to_le16(ace->e_type); > + xattr_ace->e_flags = cpu_to_le16(ace->e_flags); > + xattr_ace->e_mask = cpu_to_le32(ace->e_mask); > + if (ace->e_flags & RICHACE_SPECIAL_WHO) > + xattr_ace->e_id = cpu_to_le32(ace->e_id.special); > + else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP) > + xattr_ace->e_id = > + cpu_to_le32(from_kgid(user_ns, ace->e_id.gid)); > + else > + xattr_ace->e_id = > + cpu_to_le32(from_kuid(user_ns, ace->e_id.uid)); > + xattr_ace++; > + } > + return real_size; > +} > +EXPORT_SYMBOL_GPL(richacl_to_xattr); > diff --git a/include/linux/richacl_xattr.h b/include/linux/richacl_xattr.h > new file mode 100644 > index 0000000..0efa14b > --- /dev/null > +++ b/include/linux/richacl_xattr.h > @@ -0,0 +1,29 @@ > +/* > + * Copyright (C) 2006, 2010  Novell, Inc. > + * Copyright (C) 2015  Red Hat, Inc. > + * Written by Andreas Gruenbacher > + * > + * 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; either version 2, or (at your option) any > + * later version. > + * > + * This program is distributed in the hope that it will be useful, but > + * WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU > + * General Public License for more details. > + */ > + > +#ifndef __RICHACL_XATTR_H > +#define __RICHACL_XATTR_H > + > +#include > +#include > + > +extern struct richacl *richacl_from_xattr(struct user_namespace *, const void *, > +   size_t, int); > +extern size_t richacl_xattr_size(const struct richacl *); > +extern int richacl_to_xattr(struct user_namespace *, const struct richacl *, > +     void *, size_t); > + > +#endif /* __RICHACL_XATTR_H */ > diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild > index abeaa98..c24e106 100644 > --- a/include/uapi/linux/Kbuild > +++ b/include/uapi/linux/Kbuild > @@ -356,6 +356,7 @@ header-y += reiserfs_fs.h >  header-y += reiserfs_xattr.h >  header-y += resource.h >  header-y += richacl.h > +header-y += richacl_xattr.h >  header-y += rfkill.h >  header-y += rio_mport_cdev.h >  header-y += romfs_fs.h > diff --git a/include/uapi/linux/richacl_xattr.h b/include/uapi/linux/richacl_xattr.h > new file mode 100644 > index 0000000..20da204 > --- /dev/null > +++ b/include/uapi/linux/richacl_xattr.h > @@ -0,0 +1,44 @@ > +/* > + * Copyright (C) 2006, 2010  Novell, Inc. > + * Copyright (C) 2015  Red Hat, Inc. > + * Written by Andreas Gruenbacher > + * > + * This file is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * This file is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU > + * Lesser General Public License for more details. > + */ > + > +#ifndef __UAPI_RICHACL_XATTR_H > +#define __UAPI_RICHACL_XATTR_H > + > +#include > +#include > + > +struct richace_xattr { > + __le16 e_type; > + __le16 e_flags; > + __le32 e_mask; > + __le32 e_id; > +}; > + > +struct richacl_xattr { > + __u8 a_version; > + __u8 a_flags; > + __le16 a_count; > + __le32 a_owner_mask; > + __le32 a_group_mask; > + __le32 a_other_mask; > +}; > + > +#define RICHACL_XATTR_VERSION 0 > +#define RICHACL_XATTR_MAX_COUNT \ > + ((XATTR_SIZE_MAX - sizeof(struct richacl_xattr)) / \ > +  sizeof(struct richace_xattr)) > + > +#endif  /* __UAPI_RICHACL_XATTR_H */ > diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h > index 1590c49..1996903 100644 > --- a/include/uapi/linux/xattr.h > +++ b/include/uapi/linux/xattr.h > @@ -73,5 +73,7 @@ >  #define XATTR_POSIX_ACL_DEFAULT  "posix_acl_default" >  #define XATTR_NAME_POSIX_ACL_DEFAULT XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_DEFAULT >   > +#define XATTR_RICHACL "richacl" > +#define XATTR_NAME_RICHACL XATTR_SYSTEM_PREFIX XATTR_RICHACL >   >  #endif /* _UAPI_LINUX_XATTR_H */ Fair enough. I do wonder a bit whether we might be better served with a new set of syscalls for this instead of using xattrs (as I think Christoph has suggested). What _is_ the rationale for doing this with xattrs, btw? Regardless, this patch looks fine to me, assuming that we really do want to do this xattrs: Reviewed-by: Jeff Layton