From owner-freebsd-hackers Tue Apr 28 09:58:25 1998 Return-Path: Received: (from majordom@localhost) by hub.freebsd.org (8.8.8/8.8.8) id JAA06216 for freebsd-hackers-outgoing; Tue, 28 Apr 1998 09:58:25 -0700 (PDT) (envelope-from owner-freebsd-hackers@FreeBSD.ORG) Received: from hacker.cybernet.com (hacker.cybernet.com [192.245.33.142]) by hub.freebsd.org (8.8.8/8.8.8) with ESMTP id JAA06203 for ; Tue, 28 Apr 1998 09:58:03 -0700 (PDT) (envelope-from msuarez@cybernet.com) Received: from hacker.cybernet.com (localhost [127.0.0.1]) by hacker.cybernet.com (8.8.8/8.8.8) with ESMTP id MAA18214 for ; Tue, 28 Apr 1998 12:58:08 -0400 (EDT) (envelope-from msuarez@cybernet.com) Message-ID: X-Mailer: XFMail 1.2 [p0] on FreeBSD X-Priority: 3 (Normal) MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_" Date: Tue, 28 Apr 1998 12:58:08 -0400 (EDT) Reply-To: msuarez@cybernet.com Organization: Cybernet Systems Corp. (734) 668-2567 From: "Michael A. Suarez" To: FreeBSD Hackers Subject: Kernel Programming Question Sender: owner-freebsd-hackers@FreeBSD.ORG Precedence: bulk X-Loop: FreeBSD.ORG This message is in MIME format --_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_ Content-Type: text/plain; charset=us-ascii I am trying to make a kernel hack that does the following: If the high bit of the text segment size is set, which in any normal circumstance would be very unlikely, when that executable is loaded, a md5 checksum would be generated and stored in the proc structure of that running executable. I use the p_pad1 and p_pad2 elements of the proc structure to store upto 6 bytes of the calculated checksum. (Yes, I know this is a real hack, but I only need it for this one machine's kernel). I have coded it to the point that the checksum calculations occur if the high-bit is set. Essentially I have modified the imgact_aout to notice the high-bit is set and then set proc->p_pad1[0]=1 if it was. Then in kern_exec, I read through the executable file and, currently, only calculate and print the sum. The problem is that it only works about half the time. It fails when trying to read the file on the vn_rdwr call. It fails by simply hanging the processes, vn_rdwr does not return. If I look at the process list, the process is hung in the DV+ state. Also, the system is somewhat flakey after that. When it works, however, it calculates the sum and continues to execute the program without a hitch. I have included both the imgact_aout changes and the kern_exec changes. These are from the 2.2.2 source tree. If anyone has any suggestions, I would be very happy to hear them. Thanks, Michael msuarez@cybernet.com --_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_ Content-Disposition: attachment; filename="kern_exec.c" Content-Transfer-Encoding: base64 Content-Description: kern_exec.c Content-Type: application/octet-stream; name=kern_exec.c; SizeOnDisk=16865 LyoKICogQ29weXJpZ2h0IChjKSAxOTkzLCBEYXZpZCBHcmVlbm1hbgogKiBBbGwgcmlnaHRzIHJl c2VydmVkLgogKgogKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCiAqIGFyZSBtZXQ6CiAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CiAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQogKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgogKgogKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBBVVRIT1IgQU5E IENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5ECiAqIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQogKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRQogKiBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1Ig T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRQogKiBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTAogKiBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUwogKiBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikKICogSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QKICogTElBQklMSVRZ LCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWQogKiBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GCiAqIFNVQ0ggREFNQUdFLgogKgogKgkkSWQ6IGtlcm5f ZXhlYy5jLHYgMS40IDE5OTgvMDQvMjcgMTQ6MjU6NDUgbXN1YXJleiBFeHAgbXN1YXJleiAkCiAq LwoKI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgojaW5jbHVkZSA8c3lzL3N5c3RtLmg+CiNpbmNsdWRl IDxzeXMvc3lzcHJvdG8uaD4KI2luY2x1ZGUgPHN5cy9zaWduYWx2YXIuaD4KI2luY2x1ZGUgPHN5 cy9rZXJuZWwuaD4KI2luY2x1ZGUgPHN5cy9tb3VudC5oPgojaW5jbHVkZSA8c3lzL2ZpbGVkZXNj Lmg+CiNpbmNsdWRlIDxzeXMvZmNudGwuaD4KI2luY2x1ZGUgPHN5cy9hY2N0Lmg+CiNpbmNsdWRl IDxzeXMvZXhlYy5oPgojaW5jbHVkZSA8c3lzL2ltZ2FjdC5oPgojaW5jbHVkZSA8c3lzL2ltZ2Fj dF9lbGYuaD4KI2luY2x1ZGUgPHN5cy93YWl0Lmg+CiNpbmNsdWRlIDxzeXMvcHJvYy5oPgojaW5j bHVkZSA8c3lzL21hbGxvYy5oPgojaW5jbHVkZSA8c3lzL25hbWVpLmg+CiNpbmNsdWRlIDxzeXMv c3lzZW50Lmg+CiNpbmNsdWRlIDxzeXMvc2htLmg+CiNpbmNsdWRlIDxzeXMvc3lzY3RsLmg+CiNp bmNsdWRlIDxzeXMvdm5vZGUuaD4KI2luY2x1ZGUgPHN5cy9idWYuaD4KCiNpbmNsdWRlIDx2bS92 bS5oPgojaW5jbHVkZSA8dm0vdm1fcGFyYW0uaD4KI2luY2x1ZGUgPHZtL3ZtX3Byb3QuaD4KI2lu Y2x1ZGUgPHZtL2xvY2suaD4KI2luY2x1ZGUgPHZtL3BtYXAuaD4KI2luY2x1ZGUgPHZtL3ZtX21h cC5oPgojaW5jbHVkZSA8dm0vdm1fa2Vybi5oPgojaW5jbHVkZSA8dm0vdm1fZXh0ZXJuLmg+CiNp bmNsdWRlIDx2bS92bV9vYmplY3QuaD4KCiNpbmNsdWRlIDxtYWNoaW5lL3JlZy5oPgoKc3RhdGlj IGludCAqZXhlY19jb3B5b3V0X3N0cmluZ3MgX19QKChzdHJ1Y3QgaW1hZ2VfcGFyYW1zICopKTsK CnN0YXRpYyBpbnQgZXhlY19jaGVja19wZXJtaXNzaW9ucyhzdHJ1Y3QgaW1hZ2VfcGFyYW1zICop OwoKLyoKICogWFhYIHRyb3VibGUgaGVyZSBpZiBzaXplb2YoY2FkZHJfdCkgIT0gc2l6ZW9mKGlu dCksIG90aGVyIHBhcnRzCiAqIG9mIHRoZSBzeXNjdGwgY29kZSBhbHNvIGFzc3VtZXMgdGhpcywg YW5kIHNpemVvZihpbnQpID09IHNpemVvZihsb25nKS4KICovCnN0YXRpYyBzdHJ1Y3QgcHNfc3Ry aW5ncyAqcHNfc3RyaW5ncyA9IFBTX1NUUklOR1M7ClNZU0NUTF9JTlQoX2tlcm4sIEtFUk5fUFNf U1RSSU5HUywgcHNfc3RyaW5ncywgMCwgJnBzX3N0cmluZ3MsIDAsICIiKTsKCnN0YXRpYyBjYWRk cl90IHVzcnN0YWNrID0gKGNhZGRyX3QpVVNSU1RBQ0s7ClNZU0NUTF9JTlQoX2tlcm4sIEtFUk5f VVNSU1RBQ0ssIHVzcnN0YWNrLCAwLCAmdXNyc3RhY2ssIDAsICIiKTsKCi8qCiAqIGV4ZWNzd19z ZXQgaXMgY29uc3RydWN0ZWQgZm9yIHVzIGJ5IHRoZSBsaW5rZXIuICBFYWNoIG9mIHRoZSBpdGVt cwogKiBpcyBhIHBvaW50ZXIgdG8gYSBgY29uc3Qgc3RydWN0IGV4ZWNzdycsIGhlbmNlIHRoZSBk b3VibGUgcG9pbnRlciBoZXJlLgogKi8Kc3RhdGljIGNvbnN0IHN0cnVjdCBleGVjc3cgKipleGVj c3cgPSAKCShjb25zdCBzdHJ1Y3QgZXhlY3N3ICoqKSZleGVjc3dfc2V0LmxzX2l0ZW1zWzBdOwoK I2lmbmRlZiBfU1lTX1NZU1BST1RPX0hfCnN0cnVjdCBleGVjdmVfYXJncyB7CiAgICAgICAgY2hh ciAgICAqZm5hbWU7IAogICAgICAgIGNoYXIgICAgKiphcmd2OwogICAgICAgIGNoYXIgICAgKipl bnZ2OyAKfTsKI2VuZGlmCgovKgogKiBleGVjdmUoKSBzeXN0ZW0gY2FsbC4KICovCmludApleGVj dmUocCwgdWFwLCByZXR2YWwpCglzdHJ1Y3QgcHJvYyAqcDsKCXJlZ2lzdGVyIHN0cnVjdCBleGVj dmVfYXJncyAqdWFwOwoJaW50ICpyZXR2YWw7CnsKCXN0cnVjdCBuYW1laWRhdGEgbmQsICpuZHA7 CglpbnQgKnN0YWNrX2Jhc2U7CglpbnQgZXJyb3IsIGxlbiwgaTsKCXN0cnVjdCBpbWFnZV9wYXJh bXMgaW1hZ2VfcGFyYW1zLCAqaW1ncDsKCXN0cnVjdCB2YXR0ciBhdHRyOwoJc3RydWN0IGJ1ZiAq YnAgPSBOVUxMOwoKCWltZ3AgPSAmaW1hZ2VfcGFyYW1zOwoKCS8qCgkgKiBJbml0aWFsaXplIHBh cnQgb2YgdGhlIGNvbW1vbiBkYXRhCgkgKi8KCWltZ3AtPnByb2MgPSBwOwoJaW1ncC0+dWFwID0g dWFwOwoJaW1ncC0+YXR0ciA9ICZhdHRyOwoJaW1ncC0+aW1hZ2VfaGVhZGVyID0gTlVMTDsKCWlt Z3AtPmFyZ2MgPSBpbWdwLT5lbnZjID0gMDsKCWltZ3AtPmVudHJ5X2FkZHIgPSAwOwoJaW1ncC0+ dm1zcGFjZV9kZXN0cm95ZWQgPSAwOwoJaW1ncC0+aW50ZXJwcmV0ZWQgPSAwOwoJaW1ncC0+aW50 ZXJwcmV0ZXJfbmFtZVswXSA9ICdcMCc7CglpbWdwLT5hdXhhcmdzID0gTlVMTDsKCgkvKgoJICog QWxsb2NhdGUgdGVtcG9yYXJ5IGRlbWFuZCB6ZXJvZWQgc3BhY2UgZm9yIGFyZ3VtZW50IGFuZAoJ ICoJZW52aXJvbm1lbnQgc3RyaW5ncwoJICovCglpbWdwLT5zdHJpbmdiYXNlID0gKGNoYXIgKilr bWVtX2FsbG9jX3dhaXQoZXhlY19tYXAsIEFSR19NQVgpOwoJaWYgKGltZ3AtPnN0cmluZ2Jhc2Ug PT0gTlVMTCkgewoJCWVycm9yID0gRU5PTUVNOwoJCWdvdG8gZXhlY19mYWlsOwoJfQoJaW1ncC0+ c3RyaW5ncCA9IGltZ3AtPnN0cmluZ2Jhc2U7CglpbWdwLT5zdHJpbmdzcGFjZSA9IEFSR19NQVg7 CgoJLyoKCSAqIFRyYW5zbGF0ZSB0aGUgZmlsZSBuYW1lLiBuYW1laSgpIHJldHVybnMgYSB2bm9k ZSBwb2ludGVyCgkgKglpbiBuaV92cCBhbW91bmcgb3RoZXIgdGhpbmdzLgoJICovCgluZHAgPSAm bmQ7CglORElOSVQobmRwLCBMT09LVVAsIExPQ0tMRUFGIHwgRk9MTE9XIHwgU0FWRU5BTUUsCgkg ICAgVUlPX1VTRVJTUEFDRSwgdWFwLT5mbmFtZSwgcCk7CgppbnRlcnByZXQ6CgoJZXJyb3IgPSBu YW1laShuZHApOwoJaWYgKGVycm9yKSB7CgkJa21lbV9mcmVlX3dha2V1cChleGVjX21hcCwgKHZt X29mZnNldF90KWltZ3AtPnN0cmluZ2Jhc2UsIEFSR19NQVgpOwoJCWdvdG8gZXhlY19mYWlsOwoJ fQoKCWltZ3AtPnZwID0gbmRwLT5uaV92cDsKCgkvKgoJICogQ2hlY2sgZmlsZSBwZXJtaXNzaW9u cyAoYWxzbyAnb3BlbnMnIGZpbGUpCgkgKi8KCWVycm9yID0gZXhlY19jaGVja19wZXJtaXNzaW9u cyhpbWdwKTsKCWlmIChlcnJvcikgewoJCVZPUF9VTkxPQ0soaW1ncC0+dnApOwoJCWdvdG8gZXhl Y19mYWlsX2RlYWxsb2M7Cgl9CgoJLyoKCSAqIEdldCB0aGUgaW1hZ2UgaGVhZGVyLCB3aGljaCB3 ZSBkZWZpbmUgaGVyZSBhcyBtZWFuaW5nIHRoZSBmaXJzdAoJICogcGFnZSBvZiB0aGUgZXhlY3V0 YWJsZS4KCSAqLwoJaWYgKGltZ3AtPnZwLT52X29iamVjdCAmJiBpbWdwLT52cC0+dl9tb3VudCAm JgoJICAgIGltZ3AtPnZwLT52X21vdW50LT5tbnRfc3RhdC5mX2lvc2l6ZSA+PSBQQUdFX1NJWkUg JiYKCSAgICBpbWdwLT52cC0+dl9vYmplY3QtPnVuX3BhZ2VyLnZucC52bnBfc2l6ZSA+PQoJICAg IGltZ3AtPnZwLT52X21vdW50LT5tbnRfc3RhdC5mX2lvc2l6ZSkgewoJCS8qCgkJICogR2V0IGEg YnVmZmVyIHdpdGggKGF0IGxlYXN0KSB0aGUgZmlyc3QgcGFnZS4KCQkgKi8KCQllcnJvciA9IGJy ZWFkKGltZ3AtPnZwLCAwLCBpbWdwLT52cC0+dl9tb3VudC0+bW50X3N0YXQuZl9pb3NpemUsCgkJ ICAgICBwLT5wX3VjcmVkLCAmYnApOwoJCWltZ3AtPmltYWdlX2hlYWRlciA9IGJwLT5iX2RhdGE7 Cgl9IGVsc2UgewoJCWludCByZXNpZDsKCgkJLyoKCQkgKiBUaGUgZmlsZXN5c3RlbSBibG9jayBz aXplIGlzIHRvbyBzbWFsbCwgc28gZG8gdGhpcyB0aGUgaGFyZAoJCSAqIHdheS4gTWFsbG9jIHNv bWUgc3BhY2UgYW5kIHJlYWQgUEFHRV9TSVpFIHdvcnRoIG9mIHRoZSBpbWFnZQoJCSAqIGhlYWRl ciBpbnRvIGl0LgoJCSAqLwoJCWltZ3AtPmltYWdlX2hlYWRlciA9IG1hbGxvYyhQQUdFX1NJWkUs IE1fVEVNUCwgTV9XQUlUT0spOwoJCWVycm9yID0gdm5fcmR3cihVSU9fUkVBRCwgaW1ncC0+dnAs ICh2b2lkICopaW1ncC0+aW1hZ2VfaGVhZGVyLCBQQUdFX1NJWkUsIDAsCgkJICAgIFVJT19TWVNT UEFDRSwgSU9fTk9ERUxPQ0tFRCwgcC0+cF91Y3JlZCwgJnJlc2lkLCBwKTsKCQkvKgoJCSAqIENs ZWFyIG91dCBhbnkgcmVtYWluaW5nIGp1bmsuCgkJICovCgkJaWYgKCFlcnJvciAmJiByZXNpZCkK CQkJYnplcm8oKGNoYXIgKilpbWdwLT5pbWFnZV9oZWFkZXIgKyBQQUdFX1NJWkUgLSByZXNpZCwg cmVzaWQpOwoJfQogICAgICAgICAgICAgICAgICAgIAoJLyoKCSAqIExvb3AgdGhyb3VnaCBsaXN0 IG9mIGltYWdlIGFjdGl2YXRvcnMsIGNhbGxpbmcgZWFjaCBvbmUuCgkgKglJZiB0aGVyZSBpcyBu byBtYXRjaCwgdGhlIGFjdGl2YXRvciByZXR1cm5zIC0xLiBJZiB0aGVyZQoJICoJaXMgYSBtYXRj aCwgYnV0IHRoZXJlIHdhcyBhbiBlcnJvciBkdXJpbmcgdGhlIGFjdGl2YXRpb24sCgkgKgl0aGUg ZXJyb3IgaXMgcmV0dXJuZWQuIE90aGVyd2lzZSAwIG1lYW5zIHN1Y2Nlc3MuIElmIHRoZQoJICoJ aW1hZ2UgaXMgaW50ZXJwcmV0ZWQsIGxvb3AgYmFjayB1cCBhbmQgdHJ5IGFjdGl2YXRpbmcKCSAq CXRoZSBpbnRlcnByZXRlci4KCSAqLwoJZm9yIChpID0gMDsgZXhlY3N3W2ldOyArK2kpIHsKCQlp ZiAoZXhlY3N3W2ldLT5leF9pbWdhY3QpCgkJCWVycm9yID0gKCpleGVjc3dbaV0tPmV4X2ltZ2Fj dCkoaW1ncCk7CgkJZWxzZQoJCQljb250aW51ZTsKCQlpZiAoZXJyb3IgPT0gLTEpCgkJCWNvbnRp bnVlOwoJCWlmIChlcnJvcikgewogICAgICAgICAgICAgICAgCVZPUF9VTkxPQ0soaW1ncC0+dnAp OwoJCQlnb3RvIGV4ZWNfZmFpbF9kZWFsbG9jOwogICAgICAgICAgICAgICAgfQoJCWlmIChpbWdw LT5pbnRlcnByZXRlZCkgewoJCQkvKiBmcmVlIG9sZCBicC9pbWFnZV9oZWFkZXIgKi8KCQkJaWYg KGJwICE9IE5VTEwpIHsKCQkJCWJyZWxzZShicCk7CgkJCQlicCA9IE5VTEw7CgkJCX0gZWxzZSB7 CgkJCQlmcmVlKCh2b2lkICopaW1ncC0+aW1hZ2VfaGVhZGVyLCBNX1RFTVApOwoJCQkJaW1ncC0+ aW1hZ2VfaGVhZGVyID0gTlVMTDsKCQkJfQoJCQkvKiBmcmVlIG9sZCB2bm9kZSBhbmQgbmFtZSBi dWZmZXIgKi8KCQkJVk9QX1VOTE9DSyhpbWdwLT52cCk7CgkJCWlmIChlcnJvcikgZ290byBleGVj X2ZhaWxfZGVhbGxvYzsgICAgICAgICAgICAgICAgICAgICAgIAoJCQl2cmVsZShuZHAtPm5pX3Zw KTsKCQkJRlJFRShuZHAtPm5pX2NuZC5jbl9wbmJ1ZiwgTV9OQU1FSSk7CgkJCS8qIHNldCBuZXcg bmFtZSB0byB0aGF0IG9mIHRoZSBpbnRlcnByZXRlciAqLwoJCQlORElOSVQobmRwLCBMT09LVVAs IExPQ0tMRUFGIHwgRk9MTE9XIHwgU0FWRU5BTUUsCgkJCSAgICBVSU9fU1lTU1BBQ0UsIGltZ3At PmludGVycHJldGVyX25hbWUsIHApOwoJCQlnb3RvIGludGVycHJldDsKCQl9CgkJYnJlYWs7Cgl9 CgkvKiBJZiB3ZSBtYWRlIGl0IHRocm91Z2ggYWxsIHRoZSBhY3RpdmF0b3JzIGFuZCBub25lIG1h dGNoZWQsIGV4aXQuICovCglpZiAoZXJyb3IgPT0gLTEpIHsKICAgICAgICAJVk9QX1VOTE9DSyhp bWdwLT52cCk7CgkJZXJyb3IgPSBFTk9FWEVDOwoJCWdvdG8gZXhlY19mYWlsX2RlYWxsb2M7Cgl9 CgogICAgICAgIGlmKGltZ3AtPnByb2MtPnBfcGFkMVswXSkgCiAgICAgICAgIHsKICAgICAgICAg IHVfaW50MzJfdCByZXNpZD0wLCBlcnJvcj0wLCBzdW09MCwgb2Zmc2V0PTA7CiAgICAgICAgICB1 bnNpZ25lZCBjaGFyICpidWY7CiAgICAgICAgICAKICAgICAgICAgIGJ1Zj0odW5zaWduZWQgY2hh ciAqKSBtYWxsb2MoUEFHRV9TSVpFLCBNX1RFTVAsIE1fV0FJVE9LKTsKICAgICAgICAgIGlmKGJ1 ZikgCiAgICAgICAgICAgd2hpbGUoIWVycm9yICYmICFyZXNpZCkgCiAgICAgICAgICAgIHsKICAg ICAgICAgICAgIGVycm9yPXZuX3Jkd3IoVUlPX1JFQUQsaW1ncC0+dnAsKHZvaWQgKikgYnVmLFBB R0VfU0laRSxvZmZzZXQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIFVJT19TWVNTUEFDRSxJ T19OT0RFTE9DS0VELHAtPnBfdWNyZWQsJnJlc2lkLHApOwogICAgICAgICAgICAgaWYoIWVycm9y KSAKICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgIGludCB0PTA7CiAgICAgICAgICAgICAg IGlmKHJlc2lkKSBiemVybygoY2hhciAqKWJ1ZitQQUdFX1NJWkUtcmVzaWQscmVzaWQpOwogICAg ICAgICAgICAgICBmb3IodD0wOyB0PFBBR0VfU0laRS1yZXNpZDsgdCsrKSBzdW0rPWJ1Zlt0XTsK ICAgICAgICAgICAgICAgb2Zmc2V0Kz1QQUdFX1NJWkU7CiAgICAgICAgICAgICAgfQogICAgICAg ICAgICB9CiAgICAgICAgICBwcmludGYoIlNVTT0lZFxuIixzdW0pOyAgCiAgICAgICAgICBpZihi dWYpIGZyZWUoYnVmLE1fVEVNUCk7ICAgICAgICAgIAogICAgICAgICAgaW1ncC0+cHJvYy0+cF9w YWQxWzBdPTA7CiAgICAgICAgIH0KICAKICAgICAgICAKCVZPUF9VTkxPQ0soaW1ncC0+dnApOwoJ aWYgKGVycm9yKQoJCWdvdG8gZXhlY19mYWlsX2RlYWxsb2M7CgkKCS8qCgkgKiBDb3B5IG91dCBz dHJpbmdzIChhcmdzIGFuZCBlbnYpIGFuZCBpbml0aWFsaXplIHN0YWNrIGJhc2UKCSAqLwoJc3Rh Y2tfYmFzZSA9IGV4ZWNfY29weW91dF9zdHJpbmdzKGltZ3ApOwoJcC0+cF92bXNwYWNlLT52bV9t aW5zYWRkciA9IChjaGFyICopc3RhY2tfYmFzZTsKCgkvKgoJICogSWYgY3VzdG9tIHN0YWNrIGZp eHVwIHJvdXRpbmUgcHJlc2VudCBmb3IgdGhpcyBwcm9jZXNzCgkgKiBsZXQgaXQgZG8gdGhlIHN0 YWNrIHNldHVwLgoJICogRWxzZSBzdHVmZiBhcmd1bWVudCBjb3VudCBhcyBmaXJzdCBpdGVtIG9u IHN0YWNrCgkgKi8KCWlmIChwLT5wX3N5c2VudC0+c3ZfZml4dXApCgkJKCpwLT5wX3N5c2VudC0+ c3ZfZml4dXApKCZzdGFja19iYXNlLCBpbWdwKTsKCWVsc2UKCQlzdXdvcmQoLS1zdGFja19iYXNl LCBpbWdwLT5hcmdjKTsKCgkvKiBjbG9zZSBmaWxlcyBvbiBleGVjICovCglmZGNsb3NlZXhlYyhw KTsKCgkvKiByZXNldCBjYXVnaHQgc2lnbmFscyAqLwoJZXhlY3NpZ3MocCk7CgoJLyogbmFtZSB0 aGlzIHByb2Nlc3MgLSBuYW1laWV4ZWMocCwgbmRwKSAqLwoJbGVuID0gbWluKG5kcC0+bmlfY25k LmNuX25hbWVsZW4sTUFYQ09NTEVOKTsKCWJjb3B5KG5kcC0+bmlfY25kLmNuX25hbWVwdHIsIHAt PnBfY29tbSwgbGVuKTsKCXAtPnBfY29tbVtsZW5dID0gMDsKCgkvKgoJICogbWFyayBhcyBleGVj ZWQsIHdha2V1cCB0aGUgcHJvY2VzcyB0aGF0IHZmb3JrZWQgKGlmIGFueSkgYW5kIHRlbGwKCSAq IGl0IHRoYXQgaXQgbm93IGhhcyBpdCdzIG93biByZXNvdXJjZXMgYmFjawoJICovCglwLT5wX2Zs YWcgfD0gUF9FWEVDOwoJaWYgKHAtPnBfcHB0ciAmJiAocC0+cF9mbGFnICYgUF9QUFdBSVQpKSB7 CgkJcC0+cF9mbGFnICY9IH5QX1BQV0FJVDsKCQl3YWtldXAoKGNhZGRyX3QpcC0+cF9wcHRyKTsK CX0KCgkvKgoJICogSW1wbGVtZW50IGltYWdlIHNldHVpZC9zZXRnaWQuIERpc2FsbG93IGlmIHRo ZSBwcm9jZXNzIGlzCgkgKiBiZWluZyB0cmFjZWQuCgkgKi8KCWlmICgoYXR0ci52YV9tb2RlICYg KFZTVUlEIHwgVlNHSUQpKSAmJgoJICAgIChwLT5wX2ZsYWcgJiBQX1RSQUNFRCkgPT0gMCkgewoJ CS8qCgkJICogVHVybiBvZmYgc3lzY2FsbCB0cmFjaW5nIGZvciBzZXQtaWQgcHJvZ3JhbXMsIGV4 Y2VwdCBmb3IKCQkgKiByb290LgoJCSAqLwoJCWlmIChwLT5wX3RyYWNlcCAmJiBzdXNlcihwLT5w X3VjcmVkLCAmcC0+cF9hY2ZsYWcpKSB7CgkJCXAtPnBfdHJhY2VmbGFnID0gMDsKCQkJdnJlbGUo cC0+cF90cmFjZXApOwoJCQlwLT5wX3RyYWNlcCA9IE5VTEw7CgkJfQoJCS8qCgkJICogU2V0IHRo ZSBuZXcgY3JlZGVudGlhbHMuCgkJICovCgkJcC0+cF91Y3JlZCA9IGNyY29weShwLT5wX3VjcmVk KTsKCQlpZiAoYXR0ci52YV9tb2RlICYgVlNVSUQpCgkJCXAtPnBfdWNyZWQtPmNyX3VpZCA9IGF0 dHIudmFfdWlkOwoJCWlmIChhdHRyLnZhX21vZGUgJiBWU0dJRCkKCQkJcC0+cF91Y3JlZC0+Y3Jf Z3JvdXBzWzBdID0gYXR0ci52YV9naWQ7CgkJcC0+cF9mbGFnIHw9IFBfU1VHSUQ7Cgl9IGVsc2Ug ewoJICAgICAgICBpZiAocC0+cF91Y3JlZC0+Y3JfdWlkID09IHAtPnBfY3JlZC0+cF9ydWlkICYm CgkJICAgIHAtPnBfdWNyZWQtPmNyX2dpZCA9PSBwLT5wX2NyZWQtPnBfcmdpZCkKCQkJcC0+cF9m bGFnICY9IH5QX1NVR0lEOwoJfQoKCS8qCgkgKiBJbXBsZW1lbnQgY29ycmVjdCBQT1NJWCBzYXZl ZC1pZCBiZWhhdmlvci4KCSAqLwoJcC0+cF9jcmVkLT5wX3N2dWlkID0gcC0+cF91Y3JlZC0+Y3Jf dWlkOwoJcC0+cF9jcmVkLT5wX3N2Z2lkID0gcC0+cF91Y3JlZC0+Y3JfZ2lkOwoKCS8qCgkgKiBT dG9yZSB0aGUgdnAgZm9yIHVzZSBpbiBwcm9jZnMKCSAqLwoJaWYgKHAtPnBfdGV4dHZwKQkJLyog cmVsZWFzZSBvbGQgcmVmZXJlbmNlICovCgkJdnJlbGUocC0+cF90ZXh0dnApOwoJVlJFRihuZHAt Pm5pX3ZwKTsKCXAtPnBfdGV4dHZwID0gbmRwLT5uaV92cDsKCgkvKgoJICogSWYgdHJhY2luZyB0 aGUgcHJvY2VzcywgdHJhcCB0byBkZWJ1Z2dlciBzbyBicmVha3BvaW50cwoJICogCWNhbiBiZSBz ZXQgYmVmb3JlIHRoZSBwcm9ncmFtIGV4ZWN1dGVzLgoJICovCglpZiAocC0+cF9mbGFnICYgUF9U UkFDRUQpCgkJcHNpZ25hbChwLCBTSUdUUkFQKTsKCgkvKiBjbGVhciAiZm9yayBidXQgbm8gZXhl YyIgZmxhZywgYXMgd2UgX2FyZV8gZXhlY2luZyAqLwoJcC0+cF9hY2ZsYWcgJj0gfkFGT1JLOwoK CS8qIFNldCBlbnRyeSBhZGRyZXNzICovCglzZXRyZWdzKHAsIGltZ3AtPmVudHJ5X2FkZHIsICh1 X2xvbmcpc3RhY2tfYmFzZSk7CgoJLyoKCSAqIGZyZWUgdmFyaW91cyBhbGxvY2F0ZWQgcmVzb3Vy Y2VzCgkgKi8KCWttZW1fZnJlZV93YWtldXAoZXhlY19tYXAsICh2bV9vZmZzZXRfdClpbWdwLT5z dHJpbmdiYXNlLCBBUkdfTUFYKTsKCWlmIChicCAhPSBOVUxMKQoJCWJyZWxzZShicCk7CgllbHNl IGlmIChpbWdwLT5pbWFnZV9oZWFkZXIgIT0gTlVMTCkKCQlmcmVlKCh2b2lkICopaW1ncC0+aW1h Z2VfaGVhZGVyLCBNX1RFTVApOwoJdnJlbGUobmRwLT5uaV92cCk7CglGUkVFKG5kcC0+bmlfY25k LmNuX3BuYnVmLCBNX05BTUVJKTsKCglyZXR1cm4gKDApOwoKZXhlY19mYWlsX2RlYWxsb2M6Cglp ZiAoaW1ncC0+c3RyaW5nYmFzZSAhPSBOVUxMKQoJCWttZW1fZnJlZV93YWtldXAoZXhlY19tYXAs ICh2bV9vZmZzZXRfdClpbWdwLT5zdHJpbmdiYXNlLCBBUkdfTUFYKTsKCWlmIChicCAhPSBOVUxM KQoJCWJyZWxzZShicCk7CgllbHNlIGlmIChpbWdwLT5pbWFnZV9oZWFkZXIgIT0gTlVMTCkKCQlm cmVlKCh2b2lkICopaW1ncC0+aW1hZ2VfaGVhZGVyLCBNX1RFTVApOwoJaWYgKG5kcC0+bmlfdnAp IHsKCQl2cmVsZShuZHAtPm5pX3ZwKTsKCQlGUkVFKG5kcC0+bmlfY25kLmNuX3BuYnVmLCBNX05B TUVJKTsKCX0KCmV4ZWNfZmFpbDoKCWlmIChpbWdwLT52bXNwYWNlX2Rlc3Ryb3llZCkgewoJCS8q IHNvcnJ5LCBubyBtb3JlIHByb2Nlc3MgYW55bW9yZS4gZXhpdCBncmFjZWZ1bGx5ICovCgkJZXhp dDEocCwgV19FWElUQ09ERSgwLCBTSUdBQlJUKSk7CgkJLyogTk9UIFJFQUNIRUQgKi8KCQlyZXR1 cm4oMCk7Cgl9IGVsc2UgewoJCXJldHVybihlcnJvcik7Cgl9Cn0KCi8qCiAqIERlc3Ryb3kgb2xk IGFkZHJlc3Mgc3BhY2UsIGFuZCBhbGxvY2F0ZSBhIG5ldyBzdGFjawogKglUaGUgbmV3IHN0YWNr IGlzIG9ubHkgU0dST1dTSVogbGFyZ2UgYmVjYXVzZSBpdCBpcyBncm93bgogKglhdXRvbWF0aWNh bGx5IGluIHRyYXAuYy4KICovCmludApleGVjX25ld192bXNwYWNlKGltZ3ApCglzdHJ1Y3QgaW1h Z2VfcGFyYW1zICppbWdwOwp7CglpbnQgZXJyb3I7CglzdHJ1Y3Qgdm1zcGFjZSAqdm1zcGFjZSA9 IGltZ3AtPnByb2MtPnBfdm1zcGFjZTsKCWNhZGRyX3QJc3RhY2tfYWRkciA9IChjYWRkcl90KSAo VVNSU1RBQ0sgLSBTR1JPV1NJWik7CgoJaW1ncC0+dm1zcGFjZV9kZXN0cm95ZWQgPSAxOwoKCS8q IEJsb3cgYXdheSBlbnRpcmUgcHJvY2VzcyBWTSAqLwoJaWYgKHZtc3BhY2UtPnZtX3NobSkKCQlz aG1leGl0KGltZ3AtPnByb2MpOwoJcG1hcF9yZW1vdmVfcGFnZXMoJnZtc3BhY2UtPnZtX3BtYXAs IDAsIFVTUlNUQUNLKTsKCXZtX21hcF9yZW1vdmUoJnZtc3BhY2UtPnZtX21hcCwgMCwgVVNSU1RB Q0spOwoKCS8qIEFsbG9jYXRlIGEgbmV3IHN0YWNrICovCgllcnJvciA9IHZtX21hcF9maW5kKCZ2 bXNwYWNlLT52bV9tYXAsIE5VTEwsIDAsICh2bV9vZmZzZXRfdCAqKSZzdGFja19hZGRyLAoJICAg IFNHUk9XU0laLCBGQUxTRSwgVk1fUFJPVF9BTEwsIFZNX1BST1RfQUxMLCAwKTsKCWlmIChlcnJv cikKCQlyZXR1cm4oZXJyb3IpOwoKCXZtc3BhY2UtPnZtX3NzaXplID0gU0dST1dTSVogPj4gUEFH RV9TSElGVDsKCgkvKiBJbml0aWFsaXplIG1heGltdW0gc3RhY2sgYWRkcmVzcyAqLwoJdm1zcGFj ZS0+dm1fbWF4c2FkZHIgPSAoY2hhciAqKVVTUlNUQUNLIC0gTUFYU1NJWjsKCglyZXR1cm4oMCk7 Cn0KCi8qCiAqIENvcHkgb3V0IGFyZ3VtZW50IGFuZCBlbnZpcm9ubWVudCBzdHJpbmdzIGZyb20g dGhlIG9sZCBwcm9jZXNzCiAqCWFkZHJlc3Mgc3BhY2UgaW50byB0aGUgdGVtcG9yYXJ5IHN0cmlu ZyBidWZmZXIuCiAqLwppbnQKZXhlY19leHRyYWN0X3N0cmluZ3MoaW1ncCkKCXN0cnVjdCBpbWFn ZV9wYXJhbXMgKmltZ3A7CnsKCWNoYXIJKiphcmd2LCAqKmVudnY7CgljaGFyCSphcmdwLCAqZW52 cDsKCWludAllcnJvciwgbGVuZ3RoOwoKCS8qCgkgKiBleHRyYWN0IGFyZ3VtZW50cyBmaXJzdAoJ ICovCgoJYXJndiA9IGltZ3AtPnVhcC0+YXJndjsKCglpZiAoYXJndikgewoJCXdoaWxlICgoYXJn cCA9IChjYWRkcl90KSBmdXdvcmQoYXJndisrKSkpIHsKCQkJaWYgKGFyZ3AgPT0gKGNhZGRyX3Qp IC0xKQoJCQkJcmV0dXJuIChFRkFVTFQpOwoJCQlpZiAoKGVycm9yID0gY29weWluc3RyKGFyZ3As IGltZ3AtPnN0cmluZ3AsCgkJCSAgICBpbWdwLT5zdHJpbmdzcGFjZSwgJmxlbmd0aCkpKSB7CgkJ CQlpZiAoZXJyb3IgPT0gRU5BTUVUT09MT05HKQoJCQkJCXJldHVybihFMkJJRyk7CgkJCQlyZXR1 cm4gKGVycm9yKTsKCQkJfQoJCQlpbWdwLT5zdHJpbmdzcGFjZSAtPSBsZW5ndGg7CgkJCWltZ3At PnN0cmluZ3AgKz0gbGVuZ3RoOwoJCQlpbWdwLT5hcmdjKys7CgkJfQoJfQoKCS8qCgkgKiBleHRy YWN0IGVudmlyb25tZW50IHN0cmluZ3MKCSAqLwoKCWVudnYgPSBpbWdwLT51YXAtPmVudnY7CgoJ aWYgKGVudnYpIHsKCQl3aGlsZSAoKGVudnAgPSAoY2FkZHJfdCkgZnV3b3JkKGVudnYrKykpKSB7 CgkJCWlmIChlbnZwID09IChjYWRkcl90KSAtMSkKCQkJCXJldHVybiAoRUZBVUxUKTsKCQkJaWYg KChlcnJvciA9IGNvcHlpbnN0cihlbnZwLCBpbWdwLT5zdHJpbmdwLAoJCQkgICAgaW1ncC0+c3Ry aW5nc3BhY2UsICZsZW5ndGgpKSkgewoJCQkJaWYgKGVycm9yID09IEVOQU1FVE9PTE9ORykKCQkJ CQlyZXR1cm4oRTJCSUcpOwoJCQkJcmV0dXJuIChlcnJvcik7CgkJCX0KCQkJaW1ncC0+c3RyaW5n c3BhY2UgLT0gbGVuZ3RoOwoJCQlpbWdwLT5zdHJpbmdwICs9IGxlbmd0aDsKCQkJaW1ncC0+ZW52 YysrOwoJCX0KCX0KCglyZXR1cm4gKDApOwp9CgovKgogKiBDb3B5IHN0cmluZ3Mgb3V0IHRvIHRo ZSBuZXcgcHJvY2VzcyBhZGRyZXNzIHNwYWNlLCBjb25zdHJ1Y3RpbmcKICoJbmV3IGFyZyBhbmQg ZW52IHZlY3RvciB0YWJsZXMuIFJldHVybiBhIHBvaW50ZXIgdG8gdGhlIGJhc2UKICoJc28gdGhh dCBpdCBjYW4gYmUgdXNlZCBhcyB0aGUgaW5pdGlhbCBzdGFjayBwb2ludGVyLgogKi8KaW50ICoK ZXhlY19jb3B5b3V0X3N0cmluZ3MoaW1ncCkKCXN0cnVjdCBpbWFnZV9wYXJhbXMgKmltZ3A7CnsK CWludCBhcmdjLCBlbnZjOwoJY2hhciAqKnZlY3RwOwoJY2hhciAqc3RyaW5ncCwgKmRlc3RwOwoJ aW50ICpzdGFja19iYXNlOwoJc3RydWN0IHBzX3N0cmluZ3MgKmFyZ2luZm87CglpbnQgc3pzaWdj b2RlOwoKCS8qCgkgKiBDYWxjdWxhdGUgc3RyaW5nIGJhc2UgYW5kIHZlY3RvciB0YWJsZSBwb2lu dGVycy4KCSAqIEFsc28gZGVhbCB3aXRoIHNpZ25hbCB0cmFtcG9saW5lIGNvZGUgZm9yIHRoaXMg ZXhlYyB0eXBlLgoJICovCglhcmdpbmZvID0gUFNfU1RSSU5HUzsKCXN6c2lnY29kZSA9ICooaW1n cC0+cHJvYy0+cF9zeXNlbnQtPnN2X3N6c2lnY29kZSk7CglkZXN0cCA9CShjYWRkcl90KWFyZ2lu Zm8gLSBzenNpZ2NvZGUgLSBTUEFSRV9VU1JTUEFDRSAtCgkJcm91bmR1cCgoQVJHX01BWCAtIGlt Z3AtPnN0cmluZ3NwYWNlKSwgc2l6ZW9mKGNoYXIgKikpOwoKCS8qCgkgKiBpbnN0YWxsIHNpZ2Nv ZGUKCSAqLwoJaWYgKHN6c2lnY29kZSkKCQljb3B5b3V0KGltZ3AtPnByb2MtPnBfc3lzZW50LT5z dl9zaWdjb2RlLAoJCQkoKGNhZGRyX3QpYXJnaW5mbyAtIHN6c2lnY29kZSksIHN6c2lnY29kZSk7 CgoJLyoKCSAqIElmIHdlIGhhdmUgYSB2YWxpZCBhdXhhcmdzIHB0ciwgcHJlcGFyZSBzb21lIHJv b20KCSAqIG9uIHRoZSBzdGFjay4KCSAqLwoJaWYgKGltZ3AtPmF1eGFyZ3MpCgkvKgoJICogVGhl ICcrIDInIGlzIGZvciB0aGUgbnVsbCBwb2ludGVycyBhdCB0aGUgZW5kIG9mIGVhY2ggb2YgdGhl CgkgKiBhcmcgYW5kIGVudiB2ZWN0b3Igc2V0cywgYW5kICdBVF9DT1VOVCoyJyBpcyByb29tIGZv ciB0aGUKCSAqIEVMRiBBdXhhcmdzIGRhdGEuCgkgKi8KCQl2ZWN0cCA9IChjaGFyICoqKShkZXN0 cCAtIChpbWdwLT5hcmdjICsgaW1ncC0+ZW52YyArIDIgKwoJCQkJICBBVF9DT1VOVCoyKSAqIHNp emVvZihjaGFyKikpOwoJZWxzZSAKCS8qCgkgKiBUaGUgJysgMicgaXMgZm9yIHRoZSBudWxsIHBv aW50ZXJzIGF0IHRoZSBlbmQgb2YgZWFjaCBvZiB0aGUKCSAqIGFyZyBhbmQgZW52IHZlY3RvciBz ZXRzCgkgKi8KCQl2ZWN0cCA9IChjaGFyICoqKQoJCQkoZGVzdHAgLSAoaW1ncC0+YXJnYyArIGlt Z3AtPmVudmMgKyAyKSAqIHNpemVvZihjaGFyKikpOwoKCS8qCgkgKiB2ZWN0cCBhbHNvIGJlY29t ZXMgb3VyIGluaXRpYWwgc3RhY2sgYmFzZQoJICovCglzdGFja19iYXNlID0gKGludCAqKXZlY3Rw OwoKCXN0cmluZ3AgPSBpbWdwLT5zdHJpbmdiYXNlOwoJYXJnYyA9IGltZ3AtPmFyZ2M7CgllbnZj ID0gaW1ncC0+ZW52YzsKCgkvKgoJICogQ29weSBvdXQgc3RyaW5ncyAtIGFyZ3VtZW50cyBhbmQg ZW52aXJvbm1lbnQuCgkgKi8KCWNvcHlvdXQoc3RyaW5ncCwgZGVzdHAsIEFSR19NQVggLSBpbWdw LT5zdHJpbmdzcGFjZSk7CgoJLyoKCSAqIEZpbGwgaW4gInBzX3N0cmluZ3MiIHN0cnVjdCBmb3Ig cHMsIHcsIGV0Yy4KCSAqLwoJc3V3b3JkKCZhcmdpbmZvLT5wc19hcmd2c3RyLCAoaW50KXZlY3Rw KTsKCXN1d29yZCgmYXJnaW5mby0+cHNfbmFyZ3ZzdHIsIGFyZ2MpOwoKCS8qCgkgKiBGaWxsIGlu IGFyZ3VtZW50IHBvcnRpb24gb2YgdmVjdG9yIHRhYmxlLgoJICovCglmb3IgKDsgYXJnYyA+IDA7 IC0tYXJnYykgewoJCXN1d29yZCh2ZWN0cCsrLCAoaW50KWRlc3RwKTsKCQl3aGlsZSAoKnN0cmlu Z3ArKyAhPSAwKQoJCQlkZXN0cCsrOwoJCWRlc3RwKys7Cgl9CgoJLyogYSBudWxsIHZlY3RvciB0 YWJsZSBwb2ludGVyIHNlcGVyYXRlcyB0aGUgYXJncCdzIGZyb20gdGhlIGVudnAncyAqLwoJc3V3 b3JkKHZlY3RwKyssIDApOwoKCXN1d29yZCgmYXJnaW5mby0+cHNfZW52c3RyLCAoaW50KXZlY3Rw KTsKCXN1d29yZCgmYXJnaW5mby0+cHNfbmVudnN0ciwgZW52Yyk7CgoJLyoKCSAqIEZpbGwgaW4g ZW52aXJvbm1lbnQgcG9ydGlvbiBvZiB2ZWN0b3IgdGFibGUuCgkgKi8KCWZvciAoOyBlbnZjID4g MDsgLS1lbnZjKSB7CgkJc3V3b3JkKHZlY3RwKyssIChpbnQpZGVzdHApOwoJCXdoaWxlICgqc3Ry aW5ncCsrICE9IDApCgkJCWRlc3RwKys7CgkJZGVzdHArKzsKCX0KCgkvKiBlbmQgb2YgdmVjdG9y IHRhYmxlIGlzIGEgbnVsbCBwb2ludGVyICovCglzdXdvcmQodmVjdHAsIDApOwoKCXJldHVybiAo c3RhY2tfYmFzZSk7Cn0KCi8qCiAqIENoZWNrIHBlcm1pc3Npb25zIG9mIGZpbGUgdG8gZXhlY3V0 ZS4KICoJUmV0dXJuIDAgZm9yIHN1Y2Nlc3Mgb3IgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8K c3RhdGljIGludApleGVjX2NoZWNrX3Blcm1pc3Npb25zKGltZ3ApCglzdHJ1Y3QgaW1hZ2VfcGFy YW1zICppbWdwOwp7CglzdHJ1Y3QgcHJvYyAqcCA9IGltZ3AtPnByb2M7CglzdHJ1Y3Qgdm5vZGUg KnZwID0gaW1ncC0+dnA7CglzdHJ1Y3QgdmF0dHIgKmF0dHIgPSBpbWdwLT5hdHRyOwoJaW50IGVy cm9yOwoKCS8qIEdldCBmaWxlIGF0dHJpYnV0ZXMgKi8KCWVycm9yID0gVk9QX0dFVEFUVFIodnAs IGF0dHIsIHAtPnBfdWNyZWQsIHApOwoJaWYgKGVycm9yKQoJCXJldHVybiAoZXJyb3IpOwoKCS8q CgkgKiAxKSBDaGVjayBpZiBmaWxlIGV4ZWN1dGlvbiBpcyBkaXNhYmxlZCBmb3IgdGhlIGZpbGVz eXN0ZW0gdGhhdCB0aGlzCgkgKglmaWxlIHJlc2lkZXMgb24uCgkgKiAyKSBJbnN1cmUgdGhhdCBh dCBsZWFzdCBvbmUgZXhlY3V0ZSBiaXQgaXMgb24gLSBvdGhlcndpc2Ugcm9vdAoJICoJd2lsbCBh bHdheXMgc3VjY2VlZCwgYW5kIHdlIGRvbid0IHdhbnQgdG8gaGFwcGVuIHVubGVzcyB0aGUKCSAq CWZpbGUgcmVhbGx5IGlzIGV4ZWN1dGFibGUuCgkgKiAzKSBJbnN1cmUgdGhhdCB0aGUgZmlsZSBp cyBhIHJlZ3VsYXIgZmlsZS4KCSAqLwoJaWYgKCh2cC0+dl9tb3VudC0+bW50X2ZsYWcgJiBNTlRf Tk9FWEVDKSB8fAoJICAgICgoYXR0ci0+dmFfbW9kZSAmIDAxMTEpID09IDApIHx8CgkgICAgKGF0 dHItPnZhX3R5cGUgIT0gVlJFRykpIHsKCQlyZXR1cm4gKEVBQ0NFUyk7Cgl9CgoJLyoKCSAqIFpl cm8gbGVuZ3RoIGZpbGVzIGNhbid0IGJlIGV4ZWMnZAoJICovCglpZiAoYXR0ci0+dmFfc2l6ZSA9 PSAwKQoJCXJldHVybiAoRU5PRVhFQyk7CgoJLyoKCSAqICBDaGVjayBmb3IgZXhlY3V0ZSBwZXJt aXNzaW9uIHRvIGZpbGUgYmFzZWQgb24gY3VycmVudCBjcmVkZW50aWFscy4KCSAqLwoJZXJyb3Ig PSBWT1BfQUNDRVNTKHZwLCBWRVhFQywgcC0+cF91Y3JlZCwgcCk7CglpZiAoZXJyb3IpCgkJcmV0 dXJuIChlcnJvcik7CgoJLyoKCSAqIENoZWNrIG51bWJlciBvZiBvcGVuLWZvci13cml0ZXMgb24g dGhlIGZpbGUgYW5kIGRlbnkgZXhlY3V0aW9uCgkgKiBpZiB0aGVyZSBhcmUgYW55LgoJICovCglp ZiAodnAtPnZfd3JpdGVjb3VudCkKCQlyZXR1cm4gKEVUWFRCU1kpOwoKCS8qCgkgKiBDYWxsIGZp bGVzeXN0ZW0gc3BlY2lmaWMgb3BlbiByb3V0aW5lICh3aGljaCBkb2VzIG5vdGhpbmcgaW4gdGhl CgkgKiBnZW5lcmFsIGNhc2UpLgoJICovCgllcnJvciA9IFZPUF9PUEVOKHZwLCBGUkVBRCwgcC0+ cF91Y3JlZCwgcCk7CglpZiAoZXJyb3IpCgkJcmV0dXJuIChlcnJvcik7CgoJLyoKCSAqIERpc2Fi bGUgc2V0dWlkL3NldGdpZCBpZiB0aGUgZmlsZXN5c3RlbSBwcm9oaWJpdHMgaXQgb3IgaWYKCSAq IHRoZSBwcm9jZXNzIGlzIGJlaW5nIHRyYWNlZC4KCSAqLwogICAgICAgIGlmICgodnAtPnZfbW91 bnQtPm1udF9mbGFnICYgTU5UX05PU1VJRCkgfHwgKHAtPnBfZmxhZyAmIFBfVFJBQ0VEKSkKCQlh dHRyLT52YV9tb2RlICY9IH4oVlNVSUQgfCBWU0dJRCk7CgoJcmV0dXJuICgwKTsKfQo= --_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_ Content-Disposition: attachment; filename="imgact_aout.c" Content-Transfer-Encoding: 7bit Content-Description: imgact_aout.c Content-Type: text/plain; charset=us-ascii; name=imgact_aout.c; SizeOnDisk=6477 /* * Copyright (c) 1993, David Greenman * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: imgact_aout.c,v 1.2 1998/04/27 09:39:10 msuarez Exp $ */ #include "opt_rlimit.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static int exec_aout_imgact __P((struct image_params *imgp)); static int exec_aout_imgact(imgp) struct image_params *imgp; { const struct exec *a_out = (const struct exec *) imgp->image_header; struct vmspace *vmspace = imgp->proc->p_vmspace; vm_offset_t vmaddr; unsigned long virtual_offset; unsigned long file_offset; unsigned long bss_size; int error; /* * Linux and *BSD binaries look very much alike, * only the machine id is different: * 0x64 for Linux, 0x86 for *BSD, 0x00 for BSDI. * NetBSD is in network byte order.. ugh. */ if (((a_out->a_magic >> 16) & 0xff) != 0x86 && ((a_out->a_magic >> 16) & 0xff) != 0 && ((((int)ntohl(a_out->a_magic)) >> 16) & 0xff) != 0x86) return -1; imgp->proc->p_pad1[0]=0; if(a_out->a_text & 0x80000000) { /* This means we need a checksum */ imgp->proc->p_pad1[0]=1; } /* * Set file/virtual offset based on a.out variant. * We do two cases: host byte order and network byte order * (for NetBSD compatibility) */ switch ((int)(a_out->a_magic & 0xffff)) { case ZMAGIC: virtual_offset = 0; if (a_out->a_text&0x7fffffff) { file_offset = PAGE_SIZE; } else { /* Bill's "screwball mode" */ file_offset = 0; } break; case QMAGIC: virtual_offset = PAGE_SIZE; file_offset = 0; break; default: /* NetBSD compatibility */ switch ((int)(ntohl(a_out->a_magic) & 0xffff)) { case ZMAGIC: case QMAGIC: virtual_offset = PAGE_SIZE; file_offset = 0; break; default: return (-1); } } bss_size = roundup(a_out->a_bss, PAGE_SIZE); /* * Check various fields in header for validity/bounds. */ if (/* entry point must lay with text region */ a_out->a_entry < virtual_offset || a_out->a_entry >= virtual_offset + (a_out->a_text&0x7fffffff) || /* text and data size must each be page rounded */ (a_out->a_text&0x7fffffff) & PAGE_MASK || a_out->a_data & PAGE_MASK) return (-1); /* text + data can't exceed file size */ if (a_out->a_data + (a_out->a_text&0x7fffffff) > imgp->attr->va_size) return (EFAULT); /* * text/data/bss must not exceed limits */ if (/* text can't exceed maximum text size */ (a_out->a_text&0x7fffffff) > MAXTSIZ || /* data + bss can't exceed maximum data size */ a_out->a_data + bss_size > MAXDSIZ || /* data + bss can't exceed rlimit */ a_out->a_data + bss_size > imgp->proc->p_rlimit[RLIMIT_DATA].rlim_cur) return (ENOMEM); /* copy in arguments and/or environment from old process */ error = exec_extract_strings(imgp); if (error) return (error); /* * Destroy old process VM and create a new one (with a new stack) */ exec_new_vmspace(imgp); /* * Map text/data read/execute */ vmaddr = virtual_offset; error = vm_mmap(&vmspace->vm_map, /* map */ &vmaddr, /* address */ (a_out->a_text&0x7fffffff) + a_out->a_data, /* size */ VM_PROT_READ | VM_PROT_EXECUTE, /* protection */ VM_PROT_ALL, /* max protection */ MAP_PRIVATE | MAP_FIXED, /* flags */ (caddr_t)imgp->vp, /* vnode */ file_offset); /* offset */ if (error) return (error); /* * allow writing of data */ vm_map_protect(&vmspace->vm_map, vmaddr + (a_out->a_text&0x7fffffff), vmaddr + (a_out->a_text&0x7fffffff) + a_out->a_data, VM_PROT_ALL, FALSE); if (bss_size != 0) { /* * Allocate demand-zeroed area for uninitialized data * "bss" = 'block started by symbol' - named after the IBM 7090 * instruction of the same name. */ vmaddr = virtual_offset + (a_out->a_text&0x7fffffff) + a_out->a_data; error = vm_map_find(&vmspace->vm_map, NULL, 0, &vmaddr, bss_size, FALSE, VM_PR OT_ALL, VM_PROT_ALL, 0); if (error) return (error); } /* Fill in process VM information */ vmspace->vm_tsize = (a_out->a_text&0x7fffffff) >> PAGE_SHIFT; vmspace->vm_dsize = (a_out->a_data + bss_size) >> PAGE_SHIFT; vmspace->vm_taddr = (caddr_t) virtual_offset; vmspace->vm_daddr = (caddr_t) virtual_offset + (a_out->a_text&0x7fffffff); /* Fill in image_params */ imgp->interpreted = 0; imgp->entry_addr = a_out->a_entry; imgp->proc->p_sysent = &aout_sysvec; /* Indicate that this file should not be modified */ imgp->vp->v_flag |= VTEXT; return (0); } /* * Tell kern_execve.c about it, with a little help from the linker. * Since `const' objects end up in the text segment, TEXT_SET is the * correct directive to use. */ static const struct execsw aout_execsw = { exec_aout_imgact, "a.out" }; TEXT_SET(execsw_set, aout_execsw); --_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_-- End of MIME message To Unsubscribe: send mail to majordomo@FreeBSD.org with "unsubscribe freebsd-hackers" in the body of the message