From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [CFT] signal/usb: Replace kill_pid_info_as_cred with kill_pid_usb_asyncio From: "Eric W. Biederman" Message-Id: <87ftszqa7k.fsf@xmission.com> Date: Thu, 07 Feb 2019 20:34:55 -0600 To: linux-usb@vger.kernel.org Cc: Greg Kroah-Hartman , Alan Stern , Oliver Neukum , linux-kernel@vger.kernel.org List-ID: VGhlIHVzYiBzdXBwb3J0IGZvciBhc3luY2lvIGVuY29kZWQgb25lIG9mIGl0J3MgdmFsdWVzIGlu IHRoZSB3cm9uZwpmaWVsZC4gIEl0IHNob3VsZCBoYXZlIHVzZWQgc2lfdmFsdWUgYnV0IGluc3Rl YWQgdXNlZCBzaV9hZGRyIHdoaWNoIGlzCm5vdCBwcmVzZW50IGluIHRoZSBfcnQgdW5pb24gbWVt YmVyIG9mIHN0cnVjdCBzaWdpbmZvLgoKVGhlIHJlc3VsdCBpcyBhIFBPU0lYIGFuZCBnbGliYyBp bmNvbXBhdGlibGUgZW5jb2Rpbmcgb2YgZmllbGRzIGluCnN0cnVjdCBzaWdpbmZvIHdpdGggc2lf Y29kZSBvZiBTSV9BU1lOQ0lPLiAgVGhpcyBtYWtlcyBpdCBpbXBvc3NpYmxlCnRvIGxvb2sgYXQg YSBzdHJ1Y3Qgc2lnaW5mbyB3aXRoIHNpX2NvZGUgc2V0IHRvIFNJX0FTWU5DSU8gYW5kIHdpdGhv dXQKY29udGV4dCBwcm9wZXJseSBkZWNvZGUgaXQuICBXaGljaCB1bmZvcnR1bmF0ZWx5IG1lYW5z IHRoYXQKY29weV9zaWdpbmZvX3RvX3VzZXIzMiBjYW4ndCBoYW5kbGUgdGhlIGNvbXBhdCBpc3N1 ZXMgdGhpcyB1bmZvcnR1bmF0ZQpjaG9pY2UgaW4gZW5jb2RpbmdzIGJyaW5ncyB1cC4KClRoZXJl Zm9yZSByZXBsYWNlIGtpbGxfcGlkX2luZm9fYXNfY3JlZCB3aXRoIGtpbGxfcGlkX3VzYl9hc3lu Y2lvIGEKZGVkaWNhdGVkIGZ1bmN0aW9uIGZvciB0aGlzIG9uZSBzcGVjaWZpYyBjYXNlLiAgVGhl cmUgYXJlIG5vIG90aGVyCnVzZXJzIG9mIGtpbGxfcGlkX2luZm9fYXNfY3JlZCBzbyB0aGlzIHNw ZWNpYWxpemF0aW9uIHNob3VsZCBoYXZlIG5vCmltcGFjdCBvbiB0aGUgYW1vbnQgb2YgY29kZSBp biB0aGUga2VybmVsLiAgSGF2ZSBraWxsX3BpZF91c2JfYXN5bmNpbwp0YWtlIGluc3RlYWQgb2Yg YSBzaWdpbmZvX3Qgd2hpY2ggaXMgZGlmZmljdWx0IGVycm9yIHByb25lIDMKYXJndW1lbnRzLCBh IHNpZ25hbCBudW1iZXIsIGFuIGVycm5vIHZhbHVlLCBhbmQgYW4gYWRkcmVzcyBlbmNvbmRlZCBh cwphIHNpZ3ZhbF90LiAgVGhlIGVuY29kaW5nIGFzIGEgc2lndmFsX3QgYWxsb3dzIHRoZSBjYWxs ZXIgdG8gZGVhbCB3aXRoCnRoZSBjb21wYXQgaXNzdWVzIGJlZm9yZSBjYWxsaW5nIGtpbGxfcGlk X2luZm9fYXNfY3JlZC4KCkFkZCBCVUlMRF9CVUdfT05zIGluIGtlcm5lbC9zaWduYWwuYyB0byBl bnN1cmUgdGhhdCB3ZSBjYW4gbm93IHBsYWNlCnRoZSBwb2ludGVyIHZhbHVlIGF0IHRoZSBpbiBz aV9waWQgKGluc3RlYWQgb2Ygc2lfYWRkcikgYW5kIGdldAp0aGUgc2FtZSBiaW5hcnkgcmVzdWx0 IHdoZW4gdGhlIHN0cnVjdHVyZSBpcyBjb3BpZWQgdG8gdXNlciBzcGFjZQphbmQgd2hlbiB0aGUg c3RydWN0dXJlIGlzIGNvcGllZCBmaWVsZCBieSBmaWVsZC4KClRoZSB1c2IgY29kZSBpcyB1cGRh dGVkIHRvIHRyYWNrIGlmIHRoZSB2YWx1ZXMgaXQgcGFzc2VzIGludG8Ka2lsbF9waWRfdXNiX2Fz eW5jaW8gd2VyZSBwYXNzZWQgdG8gaXQgZnJvbSBhIG5hdGl2ZSB1c2Vyc3BhY2UKb3IgZnJvbSBh dCBjb21wYXQgdXNlciBzcGFjZS4gIFRvIGFsbG93IGEgcHJvcGVyIGNvbnZlcnNpb24Kb2YgdGhl IGFkZHJlc3Nlcy4KCkNjOiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRp b24ub3JnPgpDYzogbGludXgtdXNiQHZnZXIua2VybmVsLm9yZwpDYzogQWxhbiBTdGVybiA8c3Rl cm5Acm93bGFuZC5oYXJ2YXJkLmVkdT4KQ2M6IE9saXZlciBOZXVrdW0gPG9uZXVrdW1Ac3VzZS5j b20+CkZpeGVzOiB2Mi4zLjM5CkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnClNpZ25lZC1vZmYt Ynk6ICJFcmljIFcuIEJpZWRlcm1hbiIgPGViaWVkZXJtQHhtaXNzaW9uLmNvbT4KLS0tCgpDYW4g SSBnZXQgc29tZW9uZSB0byB0ZXN0IHRoaXMgY29kZT8gIEkganVzdCBkaXNjb3ZlcmVkIHRoYXQg dGhlCnVzYiBjb2RlIGlzIGZpbGxpbmcgaW4gc3RydWN0IHNpZ2luZm8gd3JvbmcgYW5kIGNvcHlf c2lnaW5mb190b191c2VyMzIKY2FuJ3QgcG9zc2libHkgZ2V0IHRoaXMgY29ycmVjdCB3aXRob3V0 IHNvbWUgaGVscC4KCkkgdGhpbmsgSSBoYXZlIGNvZGVkIHVwIGEgd29ya2luZyBmaXguICBCdXQg SSBkb24ndCBoYXZlIGEgc2V0dXAKd2hlcmUgSSBjYW4gdGVzdCB0aGlzLgoKIGRyaXZlcnMvdXNi L2NvcmUvZGV2aW8uYyAgICAgfCA0NSArKysrKysrKysrKy0tLS0tLS0tLS0tLQogaW5jbHVkZS9s aW51eC9zY2hlZC9zaWduYWwuaCB8ICAyICstCiBrZXJuZWwvc2lnbmFsLmMgICAgICAgICAgICAg IHwgNjkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tCiAzIGZpbGVzIGNoYW5n ZWQsIDgzIGluc2VydGlvbnMoKyksIDMzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvdXNiL2NvcmUvZGV2aW8uYyBiL2RyaXZlcnMvdXNiL2NvcmUvZGV2aW8uYwppbmRleCBkNjU1 NjYzNDFkZDEuLmQxYTUzZjc2MGYwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY29yZS9kZXZp by5jCisrKyBiL2RyaXZlcnMvdXNiL2NvcmUvZGV2aW8uYwpAQCAtNjMsNyArNjMsNyBAQCBzdHJ1 Y3QgdXNiX2Rldl9zdGF0ZSB7CiAJdW5zaWduZWQgaW50IGRpc2NzaWducjsKIAlzdHJ1Y3QgcGlk ICpkaXNjX3BpZDsKIAljb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZDsKLQl2b2lkIF9fdXNlciAqZGlz Y2NvbnRleHQ7CisJc2lndmFsX3QgZGlzY2NvbnRleHQ7CiAJdW5zaWduZWQgbG9uZyBpZmNsYWlt ZWQ7CiAJdTMyIGRpc2FibGVkX2J1bGtfZXBzOwogCWJvb2wgcHJpdmlsZWdlc19kcm9wcGVkOwpA QCAtOTQsNiArOTQsNyBAQCBzdHJ1Y3QgYXN5bmMgewogCXN0cnVjdCB1c2JfbWVtb3J5ICp1c2Jt OwogCXVuc2lnbmVkIGludCBtZW1fdXNhZ2U7CiAJaW50IHN0YXR1czsKKwl1OCBjb21wYXRfdXNl cnVyYjsKIAl1OCBidWxrX2FkZHI7CiAJdTggYnVsa19zdGF0dXM7CiB9OwpAQCAtNTgyLDIyICs1 ODMsMjQgQEAgc3RhdGljIHZvaWQgYXN5bmNfY29tcGxldGVkKHN0cnVjdCB1cmIgKnVyYikKIHsK IAlzdHJ1Y3QgYXN5bmMgKmFzID0gdXJiLT5jb250ZXh0OwogCXN0cnVjdCB1c2JfZGV2X3N0YXRl ICpwcyA9IGFzLT5wczsKLQlzdHJ1Y3Qga2VybmVsX3NpZ2luZm8gc2luZm87CiAJc3RydWN0IHBp ZCAqcGlkID0gTlVMTDsKIAljb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCA9IE5VTEw7CiAJdW5zaWdu ZWQgbG9uZyBmbGFnczsKLQlpbnQgc2lnbnI7CisJc2lndmFsX3QgYWRkcjsKKwlpbnQgc2lnbnIs IGVycm5vOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnBzLT5sb2NrLCBmbGFncyk7CiAJbGlzdF9t b3ZlX3RhaWwoJmFzLT5hc3luY2xpc3QsICZwcy0+YXN5bmNfY29tcGxldGVkKTsKIAlhcy0+c3Rh dHVzID0gdXJiLT5zdGF0dXM7CiAJc2lnbnIgPSBhcy0+c2lnbnI7CiAJaWYgKHNpZ25yKSB7Ci0J CWNsZWFyX3NpZ2luZm8oJnNpbmZvKTsKLQkJc2luZm8uc2lfc2lnbm8gPSBhcy0+c2lnbnI7Ci0J CXNpbmZvLnNpX2Vycm5vID0gYXMtPnN0YXR1czsKLQkJc2luZm8uc2lfY29kZSA9IFNJX0FTWU5D SU87Ci0JCXNpbmZvLnNpX2FkZHIgPSBhcy0+dXNlcnVyYjsKKwkJZXJybm8gPSBhcy0+c3RhdHVz OworI2lmZGVmIENPTkZJR19DT01QQVQKKwkJaWYgKGFzLT5jb21wYXRfdXNlcnVyYikKKwkJCWFk ZHIuc2l2YWxfaW50ID0gcHRyX3RvX2NvbXBhdChhcy0+dXNlcnVyYik7CisJCWVsc2UKKyNlbmRp ZgorCQkJYWRkci5zaXZhbF9wdHIgPSBhcy0+dXNlcnVyYjsKIAkJcGlkID0gZ2V0X3BpZChhcy0+ cGlkKTsKIAkJY3JlZCA9IGdldF9jcmVkKGFzLT5jcmVkKTsKIAl9CkBAIC02MTUsNyArNjE4LDcg QEAgc3RhdGljIHZvaWQgYXN5bmNfY29tcGxldGVkKHN0cnVjdCB1cmIgKnVyYikKIAlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZwcy0+bG9jaywgZmxhZ3MpOwogCiAJaWYgKHNpZ25yKSB7Ci0JCWtp bGxfcGlkX2luZm9fYXNfY3JlZChzaW5mby5zaV9zaWdubywgJnNpbmZvLCBwaWQsIGNyZWQpOwor CQlraWxsX3BpZF91c2JfYXN5bmNpbyhzaWduciwgZXJybm8sIGFkZHIsIHBpZCwgY3JlZCk7CiAJ CXB1dF9waWQocGlkKTsKIAkJcHV0X2NyZWQoY3JlZCk7CiAJfQpAQCAtMTQyNyw3ICsxNDMwLDcg QEAgZmluZF9tZW1vcnlfYXJlYShzdHJ1Y3QgdXNiX2Rldl9zdGF0ZSAqcHMsIGNvbnN0IHN0cnVj dCB1c2JkZXZmc191cmIgKnV1cmIpCiAKIHN0YXRpYyBpbnQgcHJvY19kb19zdWJtaXR1cmIoc3Ry dWN0IHVzYl9kZXZfc3RhdGUgKnBzLCBzdHJ1Y3QgdXNiZGV2ZnNfdXJiICp1dXJiLAogCQkJc3Ry dWN0IHVzYmRldmZzX2lzb19wYWNrZXRfZGVzYyBfX3VzZXIgKmlzb19mcmFtZV9kZXNjLAotCQkJ dm9pZCBfX3VzZXIgKmFyZykKKwkJCXZvaWQgX191c2VyICphcmcsIGJvb2wgY29tcGF0KQogewog CXN0cnVjdCB1c2JkZXZmc19pc29fcGFja2V0X2Rlc2MgKmlzb3BrdCA9IE5VTEw7CiAJc3RydWN0 IHVzYl9ob3N0X2VuZHBvaW50ICplcDsKQEAgLTE3MjksNiArMTczMiw3IEBAIHN0YXRpYyBpbnQg cHJvY19kb19zdWJtaXR1cmIoc3RydWN0IHVzYl9kZXZfc3RhdGUgKnBzLCBzdHJ1Y3QgdXNiZGV2 ZnNfdXJiICp1dXJiCiAJaXNvcGt0ID0gTlVMTDsKIAlhcy0+cHMgPSBwczsKIAlhcy0+dXNlcnVy YiA9IGFyZzsKKwlhcy0+Y29tcGF0X3VzZXJ1cmIgPSBjb21wYXQ7CiAJaWYgKGFzLT51c2JtKSB7 CiAJCXVuc2lnbmVkIGxvbmcgdXVyYl9zdGFydCA9ICh1bnNpZ25lZCBsb25nKXV1cmItPmJ1ZmZl cjsKIApAQCAtMTgwOSw3ICsxODEzLDcgQEAgc3RhdGljIGludCBwcm9jX3N1Ym1pdHVyYihzdHJ1 Y3QgdXNiX2Rldl9zdGF0ZSAqcHMsIHZvaWQgX191c2VyICphcmcpCiAKIAlyZXR1cm4gcHJvY19k b19zdWJtaXR1cmIocHMsICZ1dXJiLAogCQkJKCgoc3RydWN0IHVzYmRldmZzX3VyYiBfX3VzZXIg KilhcmcpLT5pc29fZnJhbWVfZGVzYyksCi0JCQlhcmcpOworCQkJYXJnLCBmYWxzZSk7CiB9CiAK IHN0YXRpYyBpbnQgcHJvY191bmxpbmt1cmIoc3RydWN0IHVzYl9kZXZfc3RhdGUgKnBzLCB2b2lk IF9fdXNlciAqYXJnKQpAQCAtMTk3OSw3ICsxOTgzLDcgQEAgc3RhdGljIGludCBwcm9jX2Rpc2Nv bm5lY3RzaWduYWxfY29tcGF0KHN0cnVjdCB1c2JfZGV2X3N0YXRlICpwcywgdm9pZCBfX3VzZXIg KmEKIAlpZiAoY29weV9mcm9tX3VzZXIoJmRzLCBhcmcsIHNpemVvZihkcykpKQogCQlyZXR1cm4g LUVGQVVMVDsKIAlwcy0+ZGlzY3NpZ25yID0gZHMuc2lnbnI7Ci0JcHMtPmRpc2Njb250ZXh0ID0g Y29tcGF0X3B0cihkcy5jb250ZXh0KTsKKwlwcy0+ZGlzY2NvbnRleHQuc2l2YWxfaW50ID0gZHMu Y29udGV4dDsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjAxMyw3ICsyMDE3LDcgQEAgc3RhdGljIGlu dCBwcm9jX3N1Ym1pdHVyYl9jb21wYXQoc3RydWN0IHVzYl9kZXZfc3RhdGUgKnBzLCB2b2lkIF9f dXNlciAqYXJnKQogCiAJcmV0dXJuIHByb2NfZG9fc3VibWl0dXJiKHBzLCAmdXVyYiwKIAkJCSgo c3RydWN0IHVzYmRldmZzX3VyYjMyIF9fdXNlciAqKWFyZyktPmlzb19mcmFtZV9kZXNjLAotCQkJ YXJnKTsKKwkJCWFyZywgdHJ1ZSk7CiB9CiAKIHN0YXRpYyBpbnQgcHJvY2Vzc2NvbXBsX2NvbXBh dChzdHJ1Y3QgYXN5bmMgKmFzLCB2b2lkIF9fdXNlciAqIF9fdXNlciAqYXJnKQpAQCAtMjA5NCw3 ICsyMDk4LDcgQEAgc3RhdGljIGludCBwcm9jX2Rpc2Nvbm5lY3RzaWduYWwoc3RydWN0IHVzYl9k ZXZfc3RhdGUgKnBzLCB2b2lkIF9fdXNlciAqYXJnKQogCWlmIChjb3B5X2Zyb21fdXNlcigmZHMs IGFyZywgc2l6ZW9mKGRzKSkpCiAJCXJldHVybiAtRUZBVUxUOwogCXBzLT5kaXNjc2lnbnIgPSBk cy5zaWducjsKLQlwcy0+ZGlzY2NvbnRleHQgPSBkcy5jb250ZXh0OworCXBzLT5kaXNjY29udGV4 dC5zaXZhbF9wdHIgPSBkcy5jb250ZXh0OwogCXJldHVybiAwOwogfQogCkBAIC0yNjE2LDIyICsy NjIwLDE1IEBAIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgdXNiZGV2X2ZpbGVfb3BlcmF0 aW9ucyA9IHsKIHN0YXRpYyB2b2lkIHVzYmRldl9yZW1vdmUoc3RydWN0IHVzYl9kZXZpY2UgKnVk ZXYpCiB7CiAJc3RydWN0IHVzYl9kZXZfc3RhdGUgKnBzOwotCXN0cnVjdCBrZXJuZWxfc2lnaW5m byBzaW5mbzsKIAogCXdoaWxlICghbGlzdF9lbXB0eSgmdWRldi0+ZmlsZWxpc3QpKSB7CiAJCXBz ID0gbGlzdF9lbnRyeSh1ZGV2LT5maWxlbGlzdC5uZXh0LCBzdHJ1Y3QgdXNiX2Rldl9zdGF0ZSwg bGlzdCk7CiAJCWRlc3Ryb3lfYWxsX2FzeW5jKHBzKTsKIAkJd2FrZV91cF9hbGwoJnBzLT53YWl0 KTsKIAkJbGlzdF9kZWxfaW5pdCgmcHMtPmxpc3QpOwotCQlpZiAocHMtPmRpc2NzaWducikgewot CQkJY2xlYXJfc2lnaW5mbygmc2luZm8pOwotCQkJc2luZm8uc2lfc2lnbm8gPSBwcy0+ZGlzY3Np Z25yOwotCQkJc2luZm8uc2lfZXJybm8gPSBFUElQRTsKLQkJCXNpbmZvLnNpX2NvZGUgPSBTSV9B U1lOQ0lPOwotCQkJc2luZm8uc2lfYWRkciA9IHBzLT5kaXNjY29udGV4dDsKLQkJCWtpbGxfcGlk X2luZm9fYXNfY3JlZChwcy0+ZGlzY3NpZ25yLCAmc2luZm8sCi0JCQkJCXBzLT5kaXNjX3BpZCwg cHMtPmNyZWQpOwotCQl9CisJCWlmIChwcy0+ZGlzY3NpZ25yKQorCQkJa2lsbF9waWRfdXNiX2Fz eW5jaW8ocHMtPmRpc2NzaWduciwgRVBJUEUsIHBzLT5kaXNjY29udGV4dCwKKwkJCQkJICAgICBw cy0+ZGlzY19waWQsIHBzLT5jcmVkKTsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvc2NoZWQvc2lnbmFsLmggYi9pbmNsdWRlL2xpbnV4L3NjaGVkL3NpZ25hbC5oCmluZGV4IGUz MWQ2ODIwNGIyMy4uODBhNTE1NTVhN2UxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3NjaGVk L3NpZ25hbC5oCisrKyBiL2luY2x1ZGUvbGludXgvc2NoZWQvc2lnbmFsLmgKQEAgLTMzMCw3ICsz MzAsNyBAQCBleHRlcm4gdm9pZCBmb3JjZV9zaWdzZWd2KGludCBzaWcpOwogZXh0ZXJuIGludCBm b3JjZV9zaWdfaW5mbyhzdHJ1Y3Qga2VybmVsX3NpZ2luZm8gKik7CiBleHRlcm4gaW50IF9fa2ls bF9wZ3JwX2luZm8oaW50IHNpZywgc3RydWN0IGtlcm5lbF9zaWdpbmZvICppbmZvLCBzdHJ1Y3Qg cGlkICpwZ3JwKTsKIGV4dGVybiBpbnQga2lsbF9waWRfaW5mbyhpbnQgc2lnLCBzdHJ1Y3Qga2Vy bmVsX3NpZ2luZm8gKmluZm8sIHN0cnVjdCBwaWQgKnBpZCk7Ci1leHRlcm4gaW50IGtpbGxfcGlk X2luZm9fYXNfY3JlZChpbnQsIHN0cnVjdCBrZXJuZWxfc2lnaW5mbyAqLCBzdHJ1Y3QgcGlkICos CitleHRlcm4gaW50IGtpbGxfcGlkX3VzYl9hc3luY2lvKGludCBzaWcsIGludCBlcnJubywgc2ln dmFsX3QgYWRkciwgc3RydWN0IHBpZCAqLAogCQkJCWNvbnN0IHN0cnVjdCBjcmVkICopOwogZXh0 ZXJuIGludCBraWxsX3BncnAoc3RydWN0IHBpZCAqcGlkLCBpbnQgc2lnLCBpbnQgcHJpdik7CiBl eHRlcm4gaW50IGtpbGxfcGlkKHN0cnVjdCBwaWQgKnBpZCwgaW50IHNpZywgaW50IHByaXYpOwpk aWZmIC0tZ2l0IGEva2VybmVsL3NpZ25hbC5jIGIva2VybmVsL3NpZ25hbC5jCmluZGV4IDNkNTIy ZGQyODU4Yi4uYWNjNDNjOWE1ZmQzIDEwMDY0NAotLS0gYS9rZXJuZWwvc2lnbmFsLmMKKysrIGIv a2VybmVsL3NpZ25hbC5jCkBAIC0xNDM3LDEzICsxNDM3LDQ0IEBAIHN0YXRpYyBpbmxpbmUgYm9v bCBraWxsX2FzX2NyZWRfcGVybShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwKIAkgICAgICAgdWlk X2VxKGNyZWQtPnVpZCwgcGNyZWQtPnVpZCk7CiB9CiAKLS8qIGxpa2Uga2lsbF9waWRfaW5mbygp LCBidXQgZG9lc24ndCB1c2UgdWlkL2V1aWQgb2YgImN1cnJlbnQiICovCi1pbnQga2lsbF9waWRf aW5mb19hc19jcmVkKGludCBzaWcsIHN0cnVjdCBrZXJuZWxfc2lnaW5mbyAqaW5mbywgc3RydWN0 IHBpZCAqcGlkLAotCQkJIGNvbnN0IHN0cnVjdCBjcmVkICpjcmVkKQorLyoKKyAqIFRoZSB1c2Ig YXN5bmNpbyB1c2FnZSBvZiBzaWdpbmZvIGlzIHdyb25nLiAgVGhlIGdsaWJjIHN1cHBvcnQKKyAq IGZvciBhc3luY2lvIHdoaWNoIHVzZXMgU0lfQVNZTkNJTyBhc3N1bWVzIHRoZSBsYXlvdXQgaXMg U0lMX1JULgorICogQUtBIGFmdGVyIHRoZSBnZW5lcmljIGZpZWxkczoKKyAqCWtlcm5lbF9waWRf dAlzaV9waWQ7CisgKglrZXJuZWxfdWlkMzJfdAlzaV91aWQ7CisgKglzaWd2YWxfdAlzaV92YWx1 ZTsKKyAqCisgKiBVbmZvcnR1bmF0ZWx5IHdoZW4gdXNiIGdlbmVyYXRlcyBTSV9BU1lOQ0lPIGl0 IGFzc3VtZXMgdGhlIGxheW91dAorICogYWZ0ZXIgdGhlIGdlbmVyaWMgZmllbGRzIGlzOgorICoJ dm9pZCBfX3VzZXIgCSpzaV9hZGRyOworICoKKyAqIFRoaXMgaXMgYSBwcmFjdGljYWwgcHJvYmxl bSB3aGVuIHRoZXJlIGlzIGEgNjRiaXQgYmlnIGVuZGlhbiBrZXJuZWwKKyAqIGFuZCBhIDMyYml0 IHVzZXJzcGFjZS4gIEFzIHRoZSAzMmJpdCBhZGRyZXNzIHdpbGwgZW5jb2RlZCBpbiB0aGUgbG93 CisgKiAzMmJpdHMgb2YgdGhlIHBvaW50ZXIuICBUaG9zZSBsb3cgMzJiaXRzIHdpbGwgYmUgc3Rv cmVkIGF0IGhpZ2hlcgorICogYWRkcmVzcyB0aGFuIGFwcGVhciBpbiBhIDMyIGJpdCBwb2ludGVy LiAgU28gdXNlcnNwYWNlIHdpbGwgbm90CisgKiBzZWUgdGhlIGFkZHJlc3MgaXQgd2FzIGV4cGVj dGluZyBmb3IgaXQncyBjb21wbGV0aW9ucy4KKyAqCisgKiBUaGVyZSBpcyBub3RoaW5nIGluIHRo ZSBlbmNvZGluZyB0aGF0IGNhbiBhbGxvdworICogY29weV9zaWdpbmZvX3RvX3VzZXIzMiB0byBk ZXRlY3QgdGhpcyBjb25mdXNpb24gb2YgZm9ybWF0cywgc28KKyAqIGhhbmRsZSB0aGlzIGJ5IHJl cXVpcmluZyB0aGUgY2FsbGVyIG9mIGtpbGxfcGlkX3VzYl9hc3luY2lvIHRvCisgKiBub3RpY2Ug d2hlbiB0aGlzIHNpdHVyYXRpb24gdGFrZXMgcGxhY2UgYW5kIHRvIHN0b3JlIHRoZSAzMmJpdAor ICogcG9pbnRlciBpbiBzaXZhbF9pbnQsIGluc3RlYWQgb2Ygc2l2YWxfYWRkciBvZiB0aGUgc2ln dmFsX3QgYWRkcgorICogcGFyYW1ldGVyLgorICovCitpbnQga2lsbF9waWRfdXNiX2FzeW5jaW8o aW50IHNpZywgaW50IGVycm5vLCBzaWd2YWxfdCBhZGRyLAorCQkJIHN0cnVjdCBwaWQgKnBpZCwg Y29uc3Qgc3RydWN0IGNyZWQgKmNyZWQpCiB7Ci0JaW50IHJldCA9IC1FSU5WQUw7CisJc3RydWN0 IGtlcm5lbF9zaWdpbmZvIGluZm87CiAJc3RydWN0IHRhc2tfc3RydWN0ICpwOwogCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CisJaW50IHJldCA9IC1FSU5WQUw7CisKKwljbGVhcl9zaWdpbmZvKCZpbmZv KTsKKwlpbmZvLnNpX3NpZ25vID0gc2lnOworCWluZm8uc2lfZXJybm8gPSBlcnJubzsKKwlpbmZv LnNpX2NvZGUgPSBTSV9BU1lOQ0lPOworCSooKHNpZ3ZhbF90ICopJmluZm8uc2lfcGlkKSA9IGFk ZHI7CiAKIAlpZiAoIXZhbGlkX3NpZ25hbChzaWcpKQogCQlyZXR1cm4gcmV0OwpAQCAtMTQ1NCwx NyArMTQ4NSwxNyBAQCBpbnQga2lsbF9waWRfaW5mb19hc19jcmVkKGludCBzaWcsIHN0cnVjdCBr ZXJuZWxfc2lnaW5mbyAqaW5mbywgc3RydWN0IHBpZCAqcGlkLAogCQlyZXQgPSAtRVNSQ0g7CiAJ CWdvdG8gb3V0X3VubG9jazsKIAl9Ci0JaWYgKHNpX2Zyb211c2VyKGluZm8pICYmICFraWxsX2Fz X2NyZWRfcGVybShjcmVkLCBwKSkgeworCWlmICgha2lsbF9hc19jcmVkX3Blcm0oY3JlZCwgcCkp IHsKIAkJcmV0ID0gLUVQRVJNOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQotCXJldCA9IHNlY3Vy aXR5X3Rhc2tfa2lsbChwLCBpbmZvLCBzaWcsIGNyZWQpOworCXJldCA9IHNlY3VyaXR5X3Rhc2tf a2lsbChwLCAmaW5mbywgc2lnLCBjcmVkKTsKIAlpZiAocmV0KQogCQlnb3RvIG91dF91bmxvY2s7 CiAKIAlpZiAoc2lnKSB7CiAJCWlmIChsb2NrX3Rhc2tfc2lnaGFuZChwLCAmZmxhZ3MpKSB7Ci0J CQlyZXQgPSBfX3NlbmRfc2lnbmFsKHNpZywgaW5mbywgcCwgUElEVFlQRV9UR0lELCAwKTsKKwkJ CXJldCA9IF9fc2VuZF9zaWduYWwoc2lnLCAmaW5mbywgcCwgUElEVFlQRV9UR0lELCAwKTsKIAkJ CXVubG9ja190YXNrX3NpZ2hhbmQocCwgJmZsYWdzKTsKIAkJfSBlbHNlCiAJCQlyZXQgPSAtRVNS Q0g7CkBAIC0xNDczLDcgKzE1MDQsNyBAQCBpbnQga2lsbF9waWRfaW5mb19hc19jcmVkKGludCBz aWcsIHN0cnVjdCBrZXJuZWxfc2lnaW5mbyAqaW5mbywgc3RydWN0IHBpZCAqcGlkLAogCXJjdV9y ZWFkX3VubG9jaygpOwogCXJldHVybiByZXQ7CiB9Ci1FWFBPUlRfU1lNQk9MX0dQTChraWxsX3Bp ZF9pbmZvX2FzX2NyZWQpOworRVhQT1JUX1NZTUJPTF9HUEwoa2lsbF9waWRfdXNiX2FzeW5jaW8p OwogCiAvKgogICoga2lsbF9zb21ldGhpbmdfaW5mbygpIGludGVycHJldHMgcGlkIGluIGludGVy ZXN0aW5nIHdheXMganVzdCBsaWtlIGtpbGwoMikuCkBAIC00MzE4LDYgKzQzNDksMjggQEAgc3Rh dGljIGlubGluZSB2b2lkIHNpZ2luZm9fYnVpbGR0aW1lX2NoZWNrcyh2b2lkKQogCUNIRUNLX09G RlNFVChzaV9zeXNjYWxsKTsKIAlDSEVDS19PRkZTRVQoc2lfYXJjaCk7CiAjdW5kZWYgQ0hFQ0tf T0ZGU0VUCisKKwkvKiB1c2IgYXN5bmNpbyAqLworCUJVSUxEX0JVR19PTihvZmZzZXRvZihzdHJ1 Y3Qgc2lnaW5mbywgc2lfcGlkKSAhPQorCQkgICAgIG9mZnNldG9mKHN0cnVjdCBzaWdpbmZvLCBz aV9hZGRyKSk7CisJaWYgKHNpemVvZihpbnQpID09IHNpemVvZih2b2lkIF9fdXNlciAqKSkgewor CQlCVUlMRF9CVUdfT04oc2l6ZW9mX2ZpZWxkKHN0cnVjdCBzaWdpbmZvLCBzaV9waWQpICE9CisJ CQkgICAgIHNpemVvZih2b2lkIF9fdXNlciAqKSk7CisJfSBlbHNlIHsKKwkJQlVJTERfQlVHX09O KChzaXplb2ZfZmllbGQoc3RydWN0IHNpZ2luZm8sIHNpX3BpZCkgKworCQkJICAgICAgc2l6ZW9m X2ZpZWxkKHN0cnVjdCBzaWdpbmZvLCBzaV91aWQpKSAhPQorCQkJICAgICBzaXplb2Yodm9pZCBf X3VzZXIgKikpOworCQlCVUlMRF9CVUdfT04ob2Zmc2V0b2ZlbmQoc3RydWN0IHNpZ2luZm8sIHNp X3BpZCkgIT0KKwkJCSAgICAgb2Zmc2V0b2Yoc3RydWN0IHNpZ2luZm8sIHNpX3VpZCkpOworCX0K KyNpZmRlZiBDT05GSUdfQ09NUEFUCisJQlVJTERfQlVHX09OKG9mZnNldG9mKHN0cnVjdCBjb21w YXRfc2lnaW5mbywgc2lfcGlkKSAhPQorCQkgICAgIG9mZnNldG9mKHN0cnVjdCBjb21wYXRfc2ln aW5mbywgc2lfYWRkcikpOworCUJVSUxEX0JVR19PTihzaXplb2ZfZmllbGQoc3RydWN0IGNvbXBh dF9zaWdpbmZvLCBzaV9waWQpICE9CisJCSAgICAgc2l6ZW9mKGNvbXBhdF91cHRyX3QpKTsKKwlC VUlMRF9CVUdfT04oc2l6ZW9mX2ZpZWxkKHN0cnVjdCBjb21wYXRfc2lnaW5mbywgc2lfcGlkKSAh PQorCQkgICAgIHNpemVvZl9maWVsZChzdHJ1Y3Qgc2lnaW5mbywgc2lfcGlkKSk7CisjZW5kaWYK IH0KIAogdm9pZCBfX2luaXQgc2lnbmFsc19pbml0KHZvaWQpCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D091C282C2 for ; Fri, 8 Feb 2019 02:35:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C3B1A20869 for ; Fri, 8 Feb 2019 02:35:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727070AbfBHCfN (ORCPT ); Thu, 7 Feb 2019 21:35:13 -0500 Received: from out02.mta.xmission.com ([166.70.13.232]:42842 "EHLO out02.mta.xmission.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726801AbfBHCfM (ORCPT ); Thu, 7 Feb 2019 21:35:12 -0500 Received: from in01.mta.xmission.com ([166.70.13.51]) by out02.mta.xmission.com with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.87) (envelope-from ) id 1grw0R-00079h-GG; Thu, 07 Feb 2019 19:35:10 -0700 Received: from ip68-227-174-240.om.om.cox.net ([68.227.174.240] helo=x220.xmission.com) by in01.mta.xmission.com with esmtpsa (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.87) (envelope-from ) id 1grw0P-0007Q1-Vr; Thu, 07 Feb 2019 19:35:07 -0700 From: ebiederm@xmission.com (Eric W. Biederman) To: linux-usb@vger.kernel.org Cc: Greg Kroah-Hartman , Alan Stern , Oliver Neukum , Date: Thu, 07 Feb 2019 20:34:55 -0600 Message-ID: <87ftszqa7k.fsf@xmission.com> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-XM-SPF: eid=1grw0P-0007Q1-Vr;;;mid=<87ftszqa7k.fsf@xmission.com>;;;hst=in01.mta.xmission.com;;;ip=68.227.174.240;;;frm=ebiederm@xmission.com;;;spf=neutral X-XM-AID: U2FsdGVkX19ejdJgo6mkuAmxhp6VQjK9zgcY5f+Zclc= X-SA-Exim-Connect-IP: 68.227.174.240 X-SA-Exim-Mail-From: ebiederm@xmission.com Subject: [CFT][PATCH] signal/usb: Replace kill_pid_info_as_cred with kill_pid_usb_asyncio X-SA-Exim-Version: 4.2.1 (built Thu, 05 May 2016 13:38:54 -0600) X-SA-Exim-Scanned: Yes (on in01.mta.xmission.com) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The usb support for asyncio encoded one of it's values in the wrong field. It should have used si_value but instead used si_addr which is not present in the _rt union member of struct siginfo. The result is a POSIX and glibc incompatible encoding of fields in struct siginfo with si_code of SI_ASYNCIO. This makes it impossible to look at a struct siginfo with si_code set to SI_ASYNCIO and without context properly decode it. Which unfortunately means that copy_siginfo_to_user32 can't handle the compat issues this unfortunate choice in encodings brings up. Therefore replace kill_pid_info_as_cred with kill_pid_usb_asyncio a dedicated function for this one specific case. There are no other users of kill_pid_info_as_cred so this specialization should have no impact on the amont of code in the kernel. Have kill_pid_usb_asyncio take instead of a siginfo_t which is difficult error prone 3 arguments, a signal number, an errno value, and an address enconded as a sigval_t. The encoding as a sigval_t allows the caller to deal with the compat issues before calling kill_pid_info_as_cred. Add BUILD_BUG_ONs in kernel/signal.c to ensure that we can now place the pointer value at the in si_pid (instead of si_addr) and get the same binary result when the structure is copied to user space and when the structure is copied field by field. The usb code is updated to track if the values it passes into kill_pid_usb_asyncio were passed to it from a native userspace or from at compat user space. To allow a proper conversion of the addresses. Cc: Greg Kroah-Hartman Cc: linux-usb@vger.kernel.org Cc: Alan Stern Cc: Oliver Neukum Fixes: v2.3.39 Cc: stable@vger.kernel.org Signed-off-by: "Eric W. Biederman" --- Can I get someone to test this code? I just discovered that the usb code is filling in struct siginfo wrong and copy_siginfo_to_user32 can't possibly get this correct without some help. I think I have coded up a working fix. But I don't have a setup where I can test this. drivers/usb/core/devio.c | 45 +++++++++++------------ include/linux/sched/signal.h | 2 +- kernel/signal.c | 69 +++++++++++++++++++++++++++++++----- 3 files changed, 83 insertions(+), 33 deletions(-) diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c index d65566341dd1..d1a53f760f00 100644 --- a/drivers/usb/core/devio.c +++ b/drivers/usb/core/devio.c @@ -63,7 +63,7 @@ struct usb_dev_state { unsigned int discsignr; struct pid *disc_pid; const struct cred *cred; - void __user *disccontext; + sigval_t disccontext; unsigned long ifclaimed; u32 disabled_bulk_eps; bool privileges_dropped; @@ -94,6 +94,7 @@ struct async { struct usb_memory *usbm; unsigned int mem_usage; int status; + u8 compat_userurb; u8 bulk_addr; u8 bulk_status; }; @@ -582,22 +583,24 @@ static void async_completed(struct urb *urb) { struct async *as = urb->context; struct usb_dev_state *ps = as->ps; - struct kernel_siginfo sinfo; struct pid *pid = NULL; const struct cred *cred = NULL; unsigned long flags; - int signr; + sigval_t addr; + int signr, errno; spin_lock_irqsave(&ps->lock, flags); list_move_tail(&as->asynclist, &ps->async_completed); as->status = urb->status; signr = as->signr; if (signr) { - clear_siginfo(&sinfo); - sinfo.si_signo = as->signr; - sinfo.si_errno = as->status; - sinfo.si_code = SI_ASYNCIO; - sinfo.si_addr = as->userurb; + errno = as->status; +#ifdef CONFIG_COMPAT + if (as->compat_userurb) + addr.sival_int = ptr_to_compat(as->userurb); + else +#endif + addr.sival_ptr = as->userurb; pid = get_pid(as->pid); cred = get_cred(as->cred); } @@ -615,7 +618,7 @@ static void async_completed(struct urb *urb) spin_unlock_irqrestore(&ps->lock, flags); if (signr) { - kill_pid_info_as_cred(sinfo.si_signo, &sinfo, pid, cred); + kill_pid_usb_asyncio(signr, errno, addr, pid, cred); put_pid(pid); put_cred(cred); } @@ -1427,7 +1430,7 @@ find_memory_area(struct usb_dev_state *ps, const struct usbdevfs_urb *uurb) static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb, struct usbdevfs_iso_packet_desc __user *iso_frame_desc, - void __user *arg) + void __user *arg, bool compat) { struct usbdevfs_iso_packet_desc *isopkt = NULL; struct usb_host_endpoint *ep; @@ -1729,6 +1732,7 @@ static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb isopkt = NULL; as->ps = ps; as->userurb = arg; + as->compat_userurb = compat; if (as->usbm) { unsigned long uurb_start = (unsigned long)uurb->buffer; @@ -1809,7 +1813,7 @@ static int proc_submiturb(struct usb_dev_state *ps, void __user *arg) return proc_do_submiturb(ps, &uurb, (((struct usbdevfs_urb __user *)arg)->iso_frame_desc), - arg); + arg, false); } static int proc_unlinkurb(struct usb_dev_state *ps, void __user *arg) @@ -1979,7 +1983,7 @@ static int proc_disconnectsignal_compat(struct usb_dev_state *ps, void __user *a if (copy_from_user(&ds, arg, sizeof(ds))) return -EFAULT; ps->discsignr = ds.signr; - ps->disccontext = compat_ptr(ds.context); + ps->disccontext.sival_int = ds.context; return 0; } @@ -2013,7 +2017,7 @@ static int proc_submiturb_compat(struct usb_dev_state *ps, void __user *arg) return proc_do_submiturb(ps, &uurb, ((struct usbdevfs_urb32 __user *)arg)->iso_frame_desc, - arg); + arg, true); } static int processcompl_compat(struct async *as, void __user * __user *arg) @@ -2094,7 +2098,7 @@ static int proc_disconnectsignal(struct usb_dev_state *ps, void __user *arg) if (copy_from_user(&ds, arg, sizeof(ds))) return -EFAULT; ps->discsignr = ds.signr; - ps->disccontext = ds.context; + ps->disccontext.sival_ptr = ds.context; return 0; } @@ -2616,22 +2620,15 @@ const struct file_operations usbdev_file_operations = { static void usbdev_remove(struct usb_device *udev) { struct usb_dev_state *ps; - struct kernel_siginfo sinfo; while (!list_empty(&udev->filelist)) { ps = list_entry(udev->filelist.next, struct usb_dev_state, list); destroy_all_async(ps); wake_up_all(&ps->wait); list_del_init(&ps->list); - if (ps->discsignr) { - clear_siginfo(&sinfo); - sinfo.si_signo = ps->discsignr; - sinfo.si_errno = EPIPE; - sinfo.si_code = SI_ASYNCIO; - sinfo.si_addr = ps->disccontext; - kill_pid_info_as_cred(ps->discsignr, &sinfo, - ps->disc_pid, ps->cred); - } + if (ps->discsignr) + kill_pid_usb_asyncio(ps->discsignr, EPIPE, ps->disccontext, + ps->disc_pid, ps->cred); } } diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h index e31d68204b23..80a51555a7e1 100644 --- a/include/linux/sched/signal.h +++ b/include/linux/sched/signal.h @@ -330,7 +330,7 @@ extern void force_sigsegv(int sig); extern int force_sig_info(struct kernel_siginfo *); extern int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp); extern int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid); -extern int kill_pid_info_as_cred(int, struct kernel_siginfo *, struct pid *, +extern int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr, struct pid *, const struct cred *); extern int kill_pgrp(struct pid *pid, int sig, int priv); extern int kill_pid(struct pid *pid, int sig, int priv); diff --git a/kernel/signal.c b/kernel/signal.c index 3d522dd2858b..acc43c9a5fd3 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -1437,13 +1437,44 @@ static inline bool kill_as_cred_perm(const struct cred *cred, uid_eq(cred->uid, pcred->uid); } -/* like kill_pid_info(), but doesn't use uid/euid of "current" */ -int kill_pid_info_as_cred(int sig, struct kernel_siginfo *info, struct pid *pid, - const struct cred *cred) +/* + * The usb asyncio usage of siginfo is wrong. The glibc support + * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT. + * AKA after the generic fields: + * kernel_pid_t si_pid; + * kernel_uid32_t si_uid; + * sigval_t si_value; + * + * Unfortunately when usb generates SI_ASYNCIO it assumes the layout + * after the generic fields is: + * void __user *si_addr; + * + * This is a practical problem when there is a 64bit big endian kernel + * and a 32bit userspace. As the 32bit address will encoded in the low + * 32bits of the pointer. Those low 32bits will be stored at higher + * address than appear in a 32 bit pointer. So userspace will not + * see the address it was expecting for it's completions. + * + * There is nothing in the encoding that can allow + * copy_siginfo_to_user32 to detect this confusion of formats, so + * handle this by requiring the caller of kill_pid_usb_asyncio to + * notice when this situration takes place and to store the 32bit + * pointer in sival_int, instead of sival_addr of the sigval_t addr + * parameter. + */ +int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr, + struct pid *pid, const struct cred *cred) { - int ret = -EINVAL; + struct kernel_siginfo info; struct task_struct *p; unsigned long flags; + int ret = -EINVAL; + + clear_siginfo(&info); + info.si_signo = sig; + info.si_errno = errno; + info.si_code = SI_ASYNCIO; + *((sigval_t *)&info.si_pid) = addr; if (!valid_signal(sig)) return ret; @@ -1454,17 +1485,17 @@ int kill_pid_info_as_cred(int sig, struct kernel_siginfo *info, struct pid *pid, ret = -ESRCH; goto out_unlock; } - if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) { + if (!kill_as_cred_perm(cred, p)) { ret = -EPERM; goto out_unlock; } - ret = security_task_kill(p, info, sig, cred); + ret = security_task_kill(p, &info, sig, cred); if (ret) goto out_unlock; if (sig) { if (lock_task_sighand(p, &flags)) { - ret = __send_signal(sig, info, p, PIDTYPE_TGID, 0); + ret = __send_signal(sig, &info, p, PIDTYPE_TGID, 0); unlock_task_sighand(p, &flags); } else ret = -ESRCH; @@ -1473,7 +1504,7 @@ int kill_pid_info_as_cred(int sig, struct kernel_siginfo *info, struct pid *pid, rcu_read_unlock(); return ret; } -EXPORT_SYMBOL_GPL(kill_pid_info_as_cred); +EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio); /* * kill_something_info() interprets pid in interesting ways just like kill(2). @@ -4318,6 +4349,28 @@ static inline void siginfo_buildtime_checks(void) CHECK_OFFSET(si_syscall); CHECK_OFFSET(si_arch); #undef CHECK_OFFSET + + /* usb asyncio */ + BUILD_BUG_ON(offsetof(struct siginfo, si_pid) != + offsetof(struct siginfo, si_addr)); + if (sizeof(int) == sizeof(void __user *)) { + BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) != + sizeof(void __user *)); + } else { + BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) + + sizeof_field(struct siginfo, si_uid)) != + sizeof(void __user *)); + BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) != + offsetof(struct siginfo, si_uid)); + } +#ifdef CONFIG_COMPAT + BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) != + offsetof(struct compat_siginfo, si_addr)); + BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) != + sizeof(compat_uptr_t)); + BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) != + sizeof_field(struct siginfo, si_pid)); +#endif } void __init signals_init(void) -- 2.17.1