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 Received: from lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 3D099CDD55F for ; Wed, 18 Sep 2024 23:48:20 +0000 (UTC) Received: from [127.0.0.1] (helo=sfs-ml-1.v29.lw.sourceforge.com) by sfs-ml-1.v29.lw.sourceforge.com with esmtp (Exim 4.95) (envelope-from ) id 1sr4PB-0006yP-6Y; Wed, 18 Sep 2024 23:48:17 +0000 Received: from [172.30.29.66] (helo=mx.sourceforge.net) by sfs-ml-1.v29.lw.sourceforge.com with esmtps (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.95) (envelope-from ) id 1sr4P9-0006yI-UI for linux-f2fs-devel@lists.sourceforge.net; Wed, 18 Sep 2024 23:48:16 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=In-Reply-To:Content-Transfer-Encoding:Content-Type: MIME-Version:References:Message-ID:Subject:Cc:To:From:Date:Sender:Reply-To: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=Bq4y0Fv8jdzCPVmJyzH6fEjeb/DUKv+A7uX6GV5U5tw=; b=lBfVzDO1XPKKxZPU0oGaSRe7aV EZA67uUqhYFR66Btht5l9rWyXI5T0dflqu7iOcCxhX1DiT+84dg/gyBbzDtF1Keo4S28nhNcwMMKD Itf9rDalJ5rHELYdJChwbtMJ34kxM2OyBhX7wbJVP1pCV27kbglWNFlgssuqkush7sD0=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=In-Reply-To:Content-Transfer-Encoding:Content-Type:MIME-Version: References:Message-ID:Subject:Cc:To:From:Date:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=Bq4y0Fv8jdzCPVmJyzH6fEjeb/DUKv+A7uX6GV5U5tw=; b=frdhpIs+Ws8nP0h4Y2uS4Qgh/c NTZ628EKIuFqwjq4X1nQh9uprvxkQ9+pUdun0I5cTexZDvEUnlCntS8ff1x2eFN8w970AK8x+9+dq 9dpC1IwhMz8FbGkj5vkjNVAGLvFJ3sf14SFDMvEwXSwqiIHyqOyNr1iuuzwTgWr7H0e0=; Received: from dfw.source.kernel.org ([139.178.84.217]) by sfi-mx-2.v28.lw.sourceforge.com with esmtps (TLS1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.95) id 1sr4P8-0003cG-Up for linux-f2fs-devel@lists.sourceforge.net; Wed, 18 Sep 2024 23:48:16 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id A13845C59C5; Wed, 18 Sep 2024 23:48:00 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9FF05C4CEC2; Wed, 18 Sep 2024 23:48:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1726703283; bh=TwjzBhW/KGfbR9I/CrpjTeV730GGiRdHyktigv92gHQ=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=lh/U4TthaET+jwEuFYI2YfWNgwfmPovPA2j7mb2TuI8v/efBLwloDVs+OC6BbTVTz fZA+zcJtcsrjk0jrblwUP/RY/NN38m9NVFtqsole7TTCYRFzI4Yegzxc6afaTKhb8e lKh4FskhW5dMcDb0PAsJ0dSUZNDBqL7uTL+dtEIngNLAptH8R7TWd3OyIriszozyf8 3OQOB4ssBet9se1zKSmp/v20ZRD5t60ymXIU++j7onVtb0P95RjOsFQqY9f4Diefmk XGvCxJjQDFjJ1O1ZQZIjQVinia8WSpWryD490AmASWjJ+dyF4NhlgB7F3n6IsoSHC3 nAQaY8Ui9I/1g== Date: Wed, 18 Sep 2024 23:48:01 +0000 To: Daeho Jeong Message-ID: References: <20240916192014.1611002-1-daeho43@gmail.com> <20240916192014.1611002-2-daeho43@gmail.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20240916192014.1611002-2-daeho43@gmail.com> X-Headers-End: 1sr4P8-0003cG-Up Subject: Re: [f2fs-dev] [PATCH v2 2/2] mkfs.f2fs: add device aliasing feature X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Jaegeuk Kim via Linux-f2fs-devel Reply-To: Jaegeuk Kim Cc: Daeho Jeong , kernel-team@android.com, linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net SW4gZmlsZSBpbmNsdWRlZCBmcm9tIGYyZnNfZm9ybWF0LmM6MTQ6CmYyZnNfZm9ybWF0LmM6IElu IGZ1bmN0aW9uIOKAmGFsbG9jYXRlX2Jsb2Nrc19mb3JfYWxpYXNlZF9kZXZpY2XigJk6CmYyZnNf Zm9ybWF0LmM6MTcwNToyNDogZXJyb3I6IHRvbyBmZXcgYXJndW1lbnRzIHRvIGZ1bmN0aW9uIOKA mGRldl93cml0ZV9ibG9ja+KAmQogMTcwNSB8ICAgICAgICAgICAgICAgICBBU1NFUlQoZGV2X3dy aXRlX2Jsb2NrKHNpdF9ibGssIHNpdF9ibGtfYWRkcikgPj0gMCk7CiAgICAgIHwgICAgICAgICAg ICAgICAgICAgICAgICBefn5+fn5+fn5+fn5+fn4KLi4vaW5jbHVkZS9mMmZzX2ZzLmg6Mjc1OjIz OiBub3RlOiBpbiBkZWZpbml0aW9uIG9mIG1hY3JvIOKAmEFTU0VSVOKAmQogIDI3NSB8ICAgICAg ICAgICAgICAgICBpZiAoIShleHApKSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFwKICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgXn5+Ci4uL2luY2x1ZGUv ZjJmc19mcy5oOjE2NTE6MTI6IG5vdGU6IGRlY2xhcmVkIGhlcmUKIDE2NTEgfCBleHRlcm4gaW50 IGRldl93cml0ZV9ibG9jayh2b2lkICosIF9fdTY0LCBlbnVtIHJ3X2hpbnQpOwogICAgICB8ICAg ICAgICAgICAgXn5+fn5+fn5+fn5+fn5+CmYyZnNfZm9ybWF0LmM6IEluIGZ1bmN0aW9uIOKAmGYy ZnNfd3JpdGVfYWxpYXNfaW5vZGVz4oCZOgpmMmZzX2Zvcm1hdC5jOjE3NjI6MjE6IGVycm9yOiB0 b28gZmV3IGFyZ3VtZW50cyB0byBmdW5jdGlvbiDigJh3cml0ZV9pbm9kZeKAmQogMTc2MiB8ICAg ICAgICAgICAgICAgICBpZiAod3JpdGVfaW5vZGUocmF3X25vZGUsIG5vZGVfYmxrYWRkcikgPCAw KSB7CiAgICAgIHwgICAgICAgICAgICAgICAgICAgICBefn5+fn5+fn5+fgouLi9pbmNsdWRlL2Yy ZnNfZnMuaDoxNjEyOjEyOiBub3RlOiBkZWNsYXJlZCBoZXJlCiAxNjEyIHwgZXh0ZXJuIGludCB3 cml0ZV9pbm9kZShzdHJ1Y3QgZjJmc19ub2RlICosIHU2NCwgZW51bSByd19oaW50KTsKICAgICAg fCAgICAgICAgICAgIF5+fn5+fn5+fn5+CgpPbiAwOS8xNiwgRGFlaG8gSmVvbmcgd3JvdGU6Cj4g RnJvbTogRGFlaG8gSmVvbmcgPGRhZWhvamVvbmdAZ29vZ2xlLmNvbT4KPiAKPiBXZSBjYW4gYWRk IGEgZGV2aWNlIGFsaWFzaW5nIGZpbGUgd2hpY2ggY2FuIG1hcCB0aGUgd2hvbGUgZGV2aWNlIHdp dGggYW4KPiBleHRlbnQsIG5vdCB1c2luZyBub2RlIGJsb2Nrcy4gVGhpcyBtYXBwZWQgYXJlYSBz aG91bGQgYmUgcGlubmVkIGFuZAo+IG5vcm1hbGx5IHVzZWQgZm9yIHJlYWQtb25seSB1c2FnZXMu IEFmdGVyIGZpbmlzaGVkIHVzaW5nIGl0LCB3ZSBjYW4KPiBkZWFsbG9jYXRlIHRoZSB3aG9sZSBh cmVhIGFuZCByZXR1cm4gaXQgYmFjayB0byB1c2UgaXQgZm9yIG90aGVyIGZpbGVzLgo+IAo+IFNp Z25lZC1vZmYtYnk6IERhZWhvIEplb25nIDxkYWVob2plb25nQGdvb2dsZS5jb20+Cj4gLS0tCj4g djI6IHJlbW92ZWQgdW5uZWNlc3NhcnkgZGVmaW5lIGFuZCByZW5hbWVkIElTX0FMSUFTSU5HKCkK PiAtLS0KPiAgZnNjay9kdW1wLmMgICAgICAgICAgICAgfCAgMTMgKysKPiAgZnNjay9mc2NrLmMg ICAgICAgICAgICAgfCAgNDkgKysrKy0tCj4gIGZzY2svZnNjay5oICAgICAgICAgICAgIHwgICA0 ICstCj4gIGZzY2svbWFpbi5jICAgICAgICAgICAgIHwgICA1ICsKPiAgaW5jbHVkZS9mMmZzX2Zz LmggICAgICAgfCAgIDcgKwo+ICBta2ZzL2YyZnNfZm9ybWF0LmMgICAgICB8IDMzNSArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tCj4gIG1rZnMvZjJmc19mb3JtYXRfbWFp bi5jIHwgIDMwICsrKy0KPiAgNyBmaWxlcyBjaGFuZ2VkLCAzNTkgaW5zZXJ0aW9ucygrKSwgODQg ZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2ZzY2svZHVtcC5jIGIvZnNjay9kdW1wLmMK PiBpbmRleCA0NDhjMGVmLi5iZDRjN2JkIDEwMDY0NAo+IC0tLSBhL2ZzY2svZHVtcC5jCj4gKysr IGIvZnNjay9kdW1wLmMKPiBAQCAtNTI3LDYgKzUyNywxOSBAQCBzdGF0aWMgaW50IGR1bXBfaW5v ZGVfYmxrKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSwgdTMyIG5pZCwKPiAgCX0KPiAgCj4gIAlj LnNob3dfZmlsZV9tYXBfbWF4X29mZnNldCA9IGYyZnNfbWF4X2ZpbGVfb2Zmc2V0KCZub2RlX2Js ay0+aSk7Cj4gKwo+ICsJaWYgKElTX0RFVklDRV9BTElBU0lORygmbm9kZV9ibGstPmkpKSB7Cj4g KwkJdTMyIGJsa2FkZHIgPSBsZTMyX3RvX2NwdShub2RlX2Jsay0+aS5pX2V4dC5ibGtfYWRkcik7 Cj4gKwkJdTMyIGxlbiA9IGxlMzJfdG9fY3B1KG5vZGVfYmxrLT5pLmlfZXh0Lmxlbik7Cj4gKwkJ dTMyIGlkeDsKPiArCj4gKwkJZm9yIChpZHggPSAwOyBpZHggPCBsZW47IGlkeCsrKQo+ICsJCQlk dW1wX2RhdGFfYmxrKHNiaSwgaWR4ICogRjJGU19CTEtTSVpFLCBibGthZGRyKyssIGZhbHNlKTsK PiArCQlwcmludF9leHRlbnQodHJ1ZSk7Cj4gKwo+ICsJCWdvdG8gZHVtcF94YXR0cjsKPiArCX0K PiArCj4gIAlhZGRyX3Blcl9ibG9jayA9IEFERFJTX1BFUl9CTE9DSygmbm9kZV9ibGstPmkpOwo+ ICAKPiAgCS8qIGNoZWNrIGRhdGEgYmxvY2tzIGluIGlub2RlICovCj4gZGlmZiAtLWdpdCBhL2Zz Y2svZnNjay5jIGIvZnNjay9mc2NrLmMKPiBpbmRleCBhMThiZWU5Li5jOWIwZjM2IDEwMDY0NAo+ IC0tLSBhL2ZzY2svZnNjay5jCj4gKysrIGIvZnNjay9mc2NrLmMKPiBAQCAtOTAyLDYgKzkwMiw3 IEBAIHZvaWQgZnNja19jaGtfaW5vZGVfYmxrKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSwgdTMy IG5pZCwKPiAgCWludCBuZWVkX2ZpeCA9IDA7Cj4gIAlpbnQgcmV0Owo+ICAJdTMyIGNsdXN0ZXJf c2l6ZSA9IDEgPDwgbm9kZV9ibGstPmkuaV9sb2dfY2x1c3Rlcl9zaXplOwo+ICsJYm9vbCBpc19h bGlhc2luZyA9IElTX0RFVklDRV9BTElBU0lORygmbm9kZV9ibGstPmkpOwo+ICAKPiAgCWlmICgh Y29tcHJlc3NlZCkKPiAgCQlnb3RvIGNoZWNrX25leHQ7Cj4gQEAgLTExMzIsNiArMTEzMywzMyBA QCBjaGVja19uZXh0Ogo+ICAJCQkJYWRkcnNfcGVyX2JsayAqIE5JRFNfUEVSX0JMT0NLICoKPiAg CQkJCU5JRFNfUEVSX0JMT0NLKSAqIEYyRlNfQkxLU0laRTsKPiAgCX0KPiArCj4gKwlpZiAoaXNf YWxpYXNpbmcpIHsKPiArCQlzdHJ1Y3QgZXh0ZW50X2luZm8gZWk7Cj4gKwo+ICsJCWdldF9leHRl bnRfaW5mbygmZWksICZub2RlX2Jsay0+aS5pX2V4dCk7Cj4gKwkJZm9yIChpZHggPSAwOyBpZHgg PCBlaS5sZW47IGlkeCsrLCBjaGlsZC5wZ29mcysrKSB7Cj4gKwkJCWJsb2NrX3QgYmxrYWRkciA9 IGVpLmJsayArIGlkeDsKPiArCj4gKwkJCS8qIGNoZWNrIGV4dGVudCBpbmZvICovCj4gKwkJCWNo ZWNrX2V4dGVudF9pbmZvKCZjaGlsZCwgYmxrYWRkciwgMCk7Cj4gKwkJCXJldCA9IGZzY2tfY2hr X2RhdGFfYmxrKHNiaSwgJm5vZGVfYmxrLT5pLCBibGthZGRyLAo+ICsJCQkJJmNoaWxkLCAoaV9i bG9ja3MgPT0gKmJsa19jbnQpLAlmdHlwZSwgbmlkLAo+ICsJCQkJaWR4LCBuaS0+dmVyc2lvbiwg bm9kZV9ibGspOwo+ICsJCQlpZiAoIXJldCkgewo+ICsJCQkJKmJsa19jbnQgPSAqYmxrX2NudCAr IDE7Cj4gKwkJCQlpZiAoY3VyX3F0eXBlICE9IC0xKQo+ICsJCQkJCXFmX2xhc3RfYmxrb2ZzW2N1 cl9xdHlwZV0gPSBjaGlsZC5wZ29mczsKPiArCQkJfSBlbHNlIGlmIChjLmZpeF9vbikgewo+ICsJ CQkJbm9kZV9ibGstPmkuaV9leHQubGVuID0gY3B1X3RvX2xlMzIoaWR4KTsKPiArCQkJCW5lZWRf Zml4ID0gMTsKPiArCQkJCWJyZWFrOwo+ICsJCQl9Cj4gKwkJfQo+ICsKPiArCQlnb3RvIGNoZWNr Owo+ICsJfQo+ICsKPiAgCWZvciAoaWR4ID0gMDsgaWR4IDwgYWRkcnM7IGlkeCsrLCBjaGlsZC5w Z29mcysrKSB7Cj4gIAkJYmxvY2tfdCBibGthZGRyID0gbGUzMl90b19jcHUobm9kZV9ibGstPmku aV9hZGRyW29mcyArIGlkeF0pOwo+ICAKPiBAQCAtMTE2NCwxMSArMTE5MiwxMSBAQCBjaGVja19u ZXh0Ogo+ICAJCQkJY2hpbGQucGdvZnMgLSBjYmMtPmNoZWFkZXJfcGdvZnMgPCBjbHVzdGVyX3Np emUpCj4gIAkJCWNiYy0+Y250Kys7Cj4gIAkJcmV0ID0gZnNja19jaGtfZGF0YV9ibGsoc2JpLAo+ IC0JCQkJSVNfQ0FTRUZPTERFRCgmbm9kZV9ibGstPmkpLAo+ICsJCQkJJm5vZGVfYmxrLT5pLAo+ ICAJCQkJYmxrYWRkciwKPiAgCQkJCSZjaGlsZCwgKGlfYmxvY2tzID09ICpibGtfY250KSwKPiAg CQkJCWZ0eXBlLCBuaWQsIGlkeCwgbmktPnZlcnNpb24sCj4gLQkJCQlmaWxlX2lzX2VuY3J5cHQo Jm5vZGVfYmxrLT5pKSwgbm9kZV9ibGspOwo+ICsJCQkJbm9kZV9ibGspOwo+ICAJCWlmIChibGth ZGRyICE9IGxlMzJfdG9fY3B1KG5vZGVfYmxrLT5pLmlfYWRkcltvZnMgKyBpZHhdKSkKPiAgCQkJ bmVlZF9maXggPSAxOwo+ICAJCWlmICghcmV0KSB7Cj4gQEAgLTEzNjIsNyArMTM5MCw3IEBAIHNr aXBfYmxrY250X2ZpeDoKPiAgCX0KPiAgCj4gIAkvKiBkcm9wIGV4dGVudCBpbmZvcm1hdGlvbiB0 byBhdm9pZCBwb3RlbnRpYWwgd3JvbmcgYWNjZXNzICovCj4gLQlpZiAobmVlZF9maXggJiYgZjJm c19kZXZfaXNfd3JpdGFibGUoKSkKPiArCWlmIChuZWVkX2ZpeCAmJiBmMmZzX2Rldl9pc193cml0 YWJsZSgpICYmICFpc19hbGlhc2luZykKPiAgCQlub2RlX2Jsay0+aS5pX2V4dC5sZW4gPSAwOwo+ ICAKPiAgCWlmICgoYy5mZWF0dXJlICYgRjJGU19GRUFUVVJFX0lOT0RFX0NIS1NVTSkgJiYKPiBA QCAtMTQzNiwxMSArMTQ2NCw5IEBAIGludCBmc2NrX2Noa19kbm9kZV9ibGsoc3RydWN0IGYyZnNf c2JfaW5mbyAqc2JpLCBzdHJ1Y3QgZjJmc19pbm9kZSAqaW5vZGUsCj4gIAkJaWYgKCFjb21wcl9y ZWwgJiYgYmxrYWRkciA9PSBORVdfQUREUiAmJiBjaGlsZC0+cGdvZnMgLQo+ICAJCQkJY2JjLT5j aGVhZGVyX3Bnb2ZzIDwgY2x1c3Rlcl9zaXplKQo+ICAJCQljYmMtPmNudCsrOwo+IC0JCXJldCA9 IGZzY2tfY2hrX2RhdGFfYmxrKHNiaSwgSVNfQ0FTRUZPTERFRChpbm9kZSksCj4gLQkJCWJsa2Fk ZHIsIGNoaWxkLAo+ICsJCXJldCA9IGZzY2tfY2hrX2RhdGFfYmxrKHNiaSwgaW5vZGUsIGJsa2Fk ZHIsIGNoaWxkLAo+ICAJCQlsZTY0X3RvX2NwdShpbm9kZS0+aV9ibG9ja3MpID09ICpibGtfY250 LCBmdHlwZSwKPiAtCQkJbmlkLCBpZHgsIG5pLT52ZXJzaW9uLAo+IC0JCQlmaWxlX2lzX2VuY3J5 cHQoaW5vZGUpLCBub2RlX2Jsayk7Cj4gKwkJCW5pZCwgaWR4LCBuaS0+dmVyc2lvbiwgbm9kZV9i bGspOwo+ICAJCWlmIChibGthZGRyICE9IGxlMzJfdG9fY3B1KG5vZGVfYmxrLT5kbi5hZGRyW2lk eF0pKQo+ICAJCQluZWVkX2ZpeCA9IDE7Cj4gIAkJaWYgKCFyZXQpIHsKPiBAQCAtMjA0NCwxMiAr MjA3MCwxNSBAQCBpbnQgZnNja19jaGtfZGVudHJ5X2JsayhzdHJ1Y3QgZjJmc19zYl9pbmZvICpz YmksIGludCBjYXNlZm9sZGVkLCB1MzIgYmxrX2FkZHIsCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAK PiAtaW50IGZzY2tfY2hrX2RhdGFfYmxrKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSwgaW50IGNh c2Vmb2xkZWQsCj4gK2ludCBmc2NrX2Noa19kYXRhX2JsayhzdHJ1Y3QgZjJmc19zYl9pbmZvICpz YmksIHN0cnVjdCBmMmZzX2lub2RlICppbm9kZSwKPiAgCQl1MzIgYmxrX2FkZHIsIHN0cnVjdCBj aGlsZF9pbmZvICpjaGlsZCwgaW50IGxhc3RfYmxrLAo+ICAJCWVudW0gRklMRV9UWVBFIGZ0eXBl LCB1MzIgcGFyZW50X25pZCwgdTE2IGlkeF9pbl9ub2RlLCB1OCB2ZXIsCj4gLQkJaW50IGVuY19u YW1lLCBzdHJ1Y3QgZjJmc19ub2RlICpub2RlX2JsaykKPiArCQlzdHJ1Y3QgZjJmc19ub2RlICpu b2RlX2JsaykKPiAgewo+ICAJc3RydWN0IGYyZnNfZnNjayAqZnNjayA9IEYyRlNfRlNDSyhzYmkp Owo+ICsJaW50IGNhc2Vmb2xkZWQgPSBJU19DQVNFRk9MREVEKGlub2RlKTsKPiArCWludCBlbmNf bmFtZSA9IGZpbGVfaXNfZW5jcnlwdChpbm9kZSk7Cj4gKwlpbnQgYWxpYXNpbmcgPSBJU19ERVZJ Q0VfQUxJQVNJTkcoaW5vZGUpOwo+ICAKPiAgCS8qIElzIGl0IHJlc2VydmVkIGJsb2NrPyAqLwo+ ICAJaWYgKGJsa19hZGRyID09IE5FV19BRERSKSB7Cj4gQEAgLTIwNjIsNyArMjA5MSw3IEBAIGlu dCBmc2NrX2Noa19kYXRhX2JsayhzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmksIGludCBjYXNlZm9s ZGVkLAo+ICAJCXJldHVybiAtRUlOVkFMOwo+ICAJfQo+ICAKPiAtCWlmIChpc192YWxpZF9zc2Ff ZGF0YV9ibGsoc2JpLCBibGtfYWRkciwgcGFyZW50X25pZCwKPiArCWlmICghYWxpYXNpbmcgJiYg aXNfdmFsaWRfc3NhX2RhdGFfYmxrKHNiaSwgYmxrX2FkZHIsIHBhcmVudF9uaWQsCj4gIAkJCQkJ CWlkeF9pbl9ub2RlLCB2ZXIpKSB7Cj4gIAkJQVNTRVJUX01TRygic3VtbWFyeSBkYXRhIGJsb2Nr IGlzIG5vdCB2YWxpZC4gWzB4JXhdIiwKPiAgCQkJCQkJcGFyZW50X25pZCk7Cj4gZGlmZiAtLWdp dCBhL2ZzY2svZnNjay5oIGIvZnNjay9mc2NrLmgKPiBpbmRleCBhOGYxODdlLi5hMjYyNWVmIDEw MDY0NAo+IC0tLSBhL2ZzY2svZnNjay5oCj4gKysrIGIvZnNjay9mc2NrLmgKPiBAQCAtMTc5LDkg KzE3OSw5IEBAIGV4dGVybiBpbnQgZnNja19jaGtfaWRub2RlX2JsayhzdHJ1Y3QgZjJmc19zYl9p bmZvICosIHN0cnVjdCBmMmZzX2lub2RlICosCj4gIGV4dGVybiBpbnQgZnNja19jaGtfZGlkbm9k ZV9ibGsoc3RydWN0IGYyZnNfc2JfaW5mbyAqLCBzdHJ1Y3QgZjJmc19pbm9kZSAqLAo+ICAJCWVu dW0gRklMRV9UWVBFLCBzdHJ1Y3QgZjJmc19ub2RlICosIHUzMiAqLAo+ICAJCXN0cnVjdCBmMmZz X2NvbXByX2Jsa19jbnQgKiwgc3RydWN0IGNoaWxkX2luZm8gKik7Cj4gLWV4dGVybiBpbnQgZnNj a19jaGtfZGF0YV9ibGsoc3RydWN0IGYyZnNfc2JfaW5mbyAqLCBpbnQsCj4gK2V4dGVybiBpbnQg ZnNja19jaGtfZGF0YV9ibGsoc3RydWN0IGYyZnNfc2JfaW5mbyAqLCBzdHJ1Y3QgZjJmc19pbm9k ZSAqLAo+ICAJCXUzMiwgc3RydWN0IGNoaWxkX2luZm8gKiwgaW50LCBlbnVtIEZJTEVfVFlQRSwg dTMyLCB1MTYsIHU4LAo+IC0JCWludCwgc3RydWN0IGYyZnNfbm9kZSAqKTsKPiArCQlzdHJ1Y3Qg ZjJmc19ub2RlICopOwo+ICBleHRlcm4gaW50IGZzY2tfY2hrX2RlbnRyeV9ibGsoc3RydWN0IGYy ZnNfc2JfaW5mbyAqLCBpbnQsCj4gIAkJdTMyLCBzdHJ1Y3QgY2hpbGRfaW5mbyAqLCBpbnQsIGlu dCwgc3RydWN0IGYyZnNfbm9kZSAqKTsKPiAgaW50IGZzY2tfY2hrX2lubGluZV9kZW50cmllcyhz dHJ1Y3QgZjJmc19zYl9pbmZvICosIHN0cnVjdCBmMmZzX25vZGUgKiwKPiBkaWZmIC0tZ2l0IGEv ZnNjay9tYWluLmMgYi9mc2NrL21haW4uYwo+IGluZGV4IDg4ODE5MzYuLjlkZDgzNGYgMTAwNjQ0 Cj4gLS0tIGEvZnNjay9tYWluLmMKPiArKysgYi9mc2NrL21haW4uYwo+IEBAIC0xMDE1LDYgKzEw MTUsMTEgQEAgc3RhdGljIGludCBkb19kZWZyYWcoc3RydWN0IGYyZnNfc2JfaW5mbyAqc2JpKQo+ ICAJCXJldHVybiAtMTsKPiAgCX0KPiAgCj4gKwlpZiAoZ2V0X3NiKGZlYXR1cmUpICYgRjJGU19G RUFUVVJFX0RFVklDRV9BTElBUykgewo+ICsJCU1TRygwLCAiTm90IHN1cHBvcnQgb24gaW1hZ2Ug d2l0aCBkZXZpY2UgYWxpYXNpbmcgZmVhdHVyZS5cbiIpOwo+ICsJCXJldHVybiAtMTsKPiArCX0K PiArCj4gIAlpZiAoYy5kZWZyYWdfc3RhcnQgPiBnZXRfc2IoYmxvY2tfY291bnQpKQo+ICAJCWdv dG8gb3V0X3JhbmdlOwo+ICAJaWYgKGMuZGVmcmFnX3N0YXJ0IDwgU01fSShzYmkpLT5tYWluX2Js a2FkZHIpCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZjJmc19mcy5oIGIvaW5jbHVkZS9mMmZzX2Zz LmgKPiBpbmRleCAxNWExYzgyLi5hODM4MGRmIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZjJmc19m cy5oCj4gKysrIGIvaW5jbHVkZS9mMmZzX2ZzLmgKPiBAQCAtNDQ0LDYgKzQ0NCw3IEBAIHN0cnVj dCBkZXZpY2VfaW5mbyB7Cj4gIAl1aW50NjRfdCBzdGFydF9ibGthZGRyOwo+ICAJdWludDY0X3Qg ZW5kX2Jsa2FkZHI7Cj4gIAl1aW50MzJfdCB0b3RhbF9zZWdtZW50czsKPiArCWNoYXIgKmFsaWFz X2ZpbGVuYW1lOwo+ICAKPiAgCS8qIHRvIGhhbmRsZSB6b25lIGJsb2NrIGRldmljZXMgKi8KPiAg CWludCB6b25lZF9tb2RlbDsKPiBAQCAtNjY2LDYgKzY2Nyw4IEBAIGVudW0gewo+ICAjZGVmaW5l IEYyRlNfSU1NVVRBQkxFX0ZMCQkweDAwMDAwMDEwIC8qIEltbXV0YWJsZSBmaWxlICovCj4gICNk ZWZpbmUgRjJGU19OT0FUSU1FX0ZMCQkJMHgwMDAwMDA4MCAvKiBkbyBub3QgdXBkYXRlIGF0aW1l ICovCj4gICNkZWZpbmUgRjJGU19DQVNFRk9MRF9GTAkJMHg0MDAwMDAwMCAvKiBDYXNlZm9sZGVk IGZpbGUgKi8KPiArI2RlZmluZSBGMkZTX0RFVklDRV9BTElBU19GTAkJMHg4MDAwMDAwMCAvKiBG aWxlIGZvciBhbGlhc2luZyBhIGRldmljZSAqLwo+ICsjZGVmaW5lIElTX0RFVklDRV9BTElBU0lO RyhmaSkJKChmaSktPmlfZmxhZ3MgJiBjcHVfdG9fbGUzMihGMkZTX0RFVklDRV9BTElBU19GTCkp Cj4gIAo+ICAjZGVmaW5lIEYyRlNfRU5DX1VURjhfMTJfMQkxCj4gICNkZWZpbmUgRjJGU19FTkNf U1RSSUNUX01PREVfRkwJKDEgPDwgMCkKPiBAQCAtNjk4LDYgKzcwMSw3IEBAIGVudW0gewo+ICAj ZGVmaW5lIEYyRlNfRkVBVFVSRV9DQVNFRk9MRAkJMHgxMDAwCj4gICNkZWZpbmUgRjJGU19GRUFU VVJFX0NPTVBSRVNTSU9OCTB4MjAwMAo+ICAjZGVmaW5lIEYyRlNfRkVBVFVSRV9STwkJCTB4NDAw MAo+ICsjZGVmaW5lIEYyRlNfRkVBVFVSRV9ERVZJQ0VfQUxJQVMJMHg4MDAwCj4gIAo+ICAjZGVm aW5lIE1BWF9OUl9GRUFUVVJFCQkJMzIKPiAgCj4gQEAgLTE1MjAsMTEgKzE1MjQsMTQgQEAgc3Ry dWN0IGYyZnNfY29uZmlndXJhdGlvbiB7Cj4gIAl0aW1lX3QgZml4ZWRfdGltZTsKPiAgCWludCBy b2xsX2ZvcndhcmQ7Cj4gIAlib29sIG5lZWRfZnN5bmM7Cj4gKwlpbnQgYWxpYXNlZF9kZXZpY2Vz Owo+ICsJdWludDMyX3QgYWxpYXNlZF9zZWdtZW50czsKPiAgCj4gIAkvKiBta2ZzIHBhcmFtZXRl cnMgKi8KPiAgCWludCBmYWtlX3NlZWQ7Cj4gIAl1aW50MzJfdCBuZXh0X2ZyZWVfbmlkOwo+ICAJ dWludDMyX3QgbHBmX2lubzsKPiArCXVpbnQzMl90IGZpcnN0X2FsaWFzX2lubzsKPiAgCXVpbnQz Ml90IHJvb3RfdWlkOwo+ICAJdWludDMyX3Qgcm9vdF9naWQ7Cj4gIAl1aW50MzJfdCBibGtzaXpl Owo+IGRpZmYgLS1naXQgYS9ta2ZzL2YyZnNfZm9ybWF0LmMgYi9ta2ZzL2YyZnNfZm9ybWF0LmMK PiBpbmRleCAyNDdhODM2Li44MGIxNDBmIDEwMDY0NAo+IC0tLSBhL21rZnMvZjJmc19mb3JtYXQu Ywo+ICsrKyBiL21rZnMvZjJmc19mb3JtYXQuYwo+IEBAIC0xMyw2ICsxMyw3IEBACj4gICNpbmNs dWRlIDx1bmlzdGQuaD4KPiAgI2luY2x1ZGUgPGYyZnNfZnMuaD4KPiAgI2luY2x1ZGUgPGFzc2Vy dC5oPgo+ICsjaW5jbHVkZSA8c3RkYm9vbC5oPgo+ICAKPiAgI2lmZGVmIEhBVkVfU1lTX1NUQVRf SAo+ICAjaW5jbHVkZSA8c3lzL3N0YXQuaD4KPiBAQCAtMzksMTAgKzQwLDYyIEBAIHN0cnVjdCBm MmZzX3N1cGVyX2Jsb2NrIHJhd19zYjsKPiAgc3RydWN0IGYyZnNfc3VwZXJfYmxvY2sgKnNiID0g JnJhd19zYjsKPiAgc3RydWN0IGYyZnNfY2hlY2twb2ludCAqY3A7Cj4gIAo+ICtzdGF0aWMgaW5s aW5lIGJvb2wgZGV2aWNlX2lzX2FsaWFzZWQodW5zaWduZWQgaW50IGRldl9udW0pCj4gK3sKPiAr CWlmIChkZXZfbnVtID49IGMubmRldnMpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsJcmV0dXJuIGMu ZGV2aWNlc1tkZXZfbnVtXS5hbGlhc19maWxlbmFtZSAhPSBOVUxMOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW5saW5lIHVuc2lnbmVkIGludCB0YXJnZXRfZGV2aWNlX2luZGV4KHVpbnQ2NF90IGJsa2Fk ZHIpCj4gK3sKPiArCWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBjLm5kZXZzOyBpKysp Cj4gKwkJaWYgKGMuZGV2aWNlc1tpXS5zdGFydF9ibGthZGRyIDw9IGJsa2FkZHIgJiYKPiArCQkJ CWMuZGV2aWNlc1tpXS5lbmRfYmxrYWRkciA+PSBibGthZGRyKQo+ICsJCQlyZXR1cm4gaTsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICsjZGVmaW5lIEdFVF9TRUdOTyhibGtfYWRkcikgKChibGtf YWRkciAtIGdldF9zYihtYWluX2Jsa2FkZHIpKSAvIFwKPiArCQkJCWMuYmxrc19wZXJfc2VnKQo+ ICsjZGVmaW5lIFNUQVJUX0JMT0NLKHNlZ25vKSAoc2Vnbm8gKiBjLmJsa3NfcGVyX3NlZyArIGdl dF9zYihtYWluX2Jsa2FkZHIpKQo+ICsKPiAgLyogUmV0dXJuIGZpcnN0IHNlZ21lbnQgbnVtYmVy IG9mIGVhY2ggYXJlYSAqLwo+IC0jZGVmaW5lIHByZXZfem9uZShjdXIpCQkoYy5jdXJfc2VnW2N1 cl0gLSBjLnNlZ3NfcGVyX3pvbmUpCj4gLSNkZWZpbmUgbmV4dF96b25lKGN1cikJCShjLmN1cl9z ZWdbY3VyXSArIGMuc2Vnc19wZXJfem9uZSkKPiAtI2RlZmluZSBsYXN0X3pvbmUoY3VyKQkJKChj dXIgLSAxKSAqIGMuc2Vnc19wZXJfem9uZSkKPiArc3RhdGljIGlubGluZSB1aW50MzJfdCBuZXh0 X3pvbmUoaW50IHNlZ190eXBlKQo+ICt7Cj4gKwl1aW50MzJfdCBuZXh0X3NlZyA9IGMuY3VyX3Nl Z1tzZWdfdHlwZV0gKyBjLnNlZ3NfcGVyX3pvbmU7Cj4gKwl1aW50NjRfdCBuZXh0X2Jsa2FkZHIg PSBTVEFSVF9CTE9DSyhuZXh0X3NlZyk7Cj4gKwlpbnQgZGV2X251bTsKPiArCj4gKwlkZXZfbnVt ID0gdGFyZ2V0X2RldmljZV9pbmRleChuZXh0X2Jsa2FkZHIpOwo+ICsJaWYgKCFkZXZpY2VfaXNf YWxpYXNlZChkZXZfbnVtKSkKPiArCQlyZXR1cm4gR0VUX1NFR05PKG5leHRfYmxrYWRkcik7Cj4g Kwo+ICsJd2hpbGUgKGRldl9udW0gPCBjLm5kZXZzICYmIGRldmljZV9pc19hbGlhc2VkKGRldl9u dW0pKQo+ICsJCWRldl9udW0rKzsKPiArCj4gKwlyZXR1cm4gR0VUX1NFR05PKGMuZGV2aWNlc1tk ZXZfbnVtIC0gMV0uZW5kX2Jsa2FkZHIgKyAxKTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB1 aW50MzJfdCBsYXN0X3pvbmUodWludDMyX3QgdG90YWxfem9uZSkKPiArewo+ICsJdWludDMyX3Qg bGFzdF9zZWcgPSAodG90YWxfem9uZSAtIDEpICogYy5zZWdzX3Blcl96b25lOwo+ICsJdWludDY0 X3QgbGFzdF9ibGthZGRyID0gU1RBUlRfQkxPQ0sobGFzdF9zZWcpOwo+ICsJaW50IGRldl9udW07 Cj4gKwo+ICsJZGV2X251bSA9IHRhcmdldF9kZXZpY2VfaW5kZXgobGFzdF9ibGthZGRyKTsKPiAr CWlmICghZGV2aWNlX2lzX2FsaWFzZWQoZGV2X251bSkpCj4gKwkJcmV0dXJuIEdFVF9TRUdOTyhs YXN0X2Jsa2FkZHIpOwo+ICsKPiArCXdoaWxlIChkZXZfbnVtID4gMCAmJiBkZXZpY2VfaXNfYWxp YXNlZChkZXZfbnVtKSkKPiArCQlkZXZfbnVtLS07Cj4gKwo+ICsJcmV0dXJuIEdFVF9TRUdOTyhj LmRldmljZXNbZGV2X251bSArIDFdLnN0YXJ0X2Jsa2FkZHIpIC0KPiArCQljLnNlZ3NfcGVyX3pv bmU7Cj4gK30KPiArCj4gICNkZWZpbmUgbGFzdF9zZWN0aW9uKGN1cikJKGN1ciArIChjLnNlY3Nf cGVyX3pvbmUgLSAxKSAqIGMuc2Vnc19wZXJfc2VjKQo+ICAKPiAgLyogUmV0dXJuIHRpbWUgZml4 ZWQgYnkgdGhlIHVzZXIgb3IgY3VycmVudCB0aW1lIGJ5IGRlZmF1bHQgKi8KPiBAQCAtMjIwLDcg KzI3Myw3IEBAIHN0YXRpYyBpbnQgZjJmc19wcmVwYXJlX3N1cGVyX2Jsb2NrKHZvaWQpCj4gIAl1 aW50NjRfdCB0b3RhbF9tZXRhX3pvbmVzLCB0b3RhbF9tZXRhX3NlZ21lbnRzOwo+ICAJdWludDMy X3Qgc2l0X2JpdG1hcF9zaXplLCBtYXhfc2l0X2JpdG1hcF9zaXplOwo+ICAJdWludDMyX3QgbWF4 X25hdF9iaXRtYXBfc2l6ZSwgbWF4X25hdF9zZWdtZW50czsKPiAtCXVpbnQzMl90IHRvdGFsX3pv bmVzLCBhdmFpbF96b25lczsKPiArCXVpbnQzMl90IHRvdGFsX3pvbmVzLCBhdmFpbF96b25lcyA9 IDA7Cj4gIAllbnVtIHF1b3RhX3R5cGUgcXR5cGU7Cj4gIAlpbnQgaTsKPiAgCj4gQEAgLTMxNCw2 ICszNjcsMTYgQEAgc3RhdGljIGludCBmMmZzX3ByZXBhcmVfc3VwZXJfYmxvY2sodm9pZCkKPiAg CQkJYy5kZXZpY2VzW2ldLmVuZF9ibGthZGRyID0gYy5kZXZpY2VzW2ldLnN0YXJ0X2Jsa2FkZHIg Kwo+ICAJCQkJCWMuZGV2aWNlc1tpXS50b3RhbF9zZWdtZW50cyAqCj4gIAkJCQkJYy5ibGtzX3Bl cl9zZWcgLSAxOwo+ICsJCQlpZiAoZGV2aWNlX2lzX2FsaWFzZWQoaSkpIHsKPiArCQkJCWlmIChj LmRldmljZXNbaV0uem9uZWRfbW9kZWwgPT0KPiArCQkJCQkJRjJGU19aT05FRF9ITSkgewo+ICsJ CQkJCU1TRygxLCAiXHRFcnJvcjogZG8gbm90IHN1cHBvcnQgIgo+ICsJCQkJCSJkZXZpY2UgYWxp YXNpbmcgZm9yIGRldmljZVslZF1cbiIsIGkpOwo+ICsJCQkJCXJldHVybiAtMTsKPiArCQkJCX0K PiArCQkJCWMuYWxpYXNlZF9zZWdtZW50cyArPQo+ICsJCQkJCWMuZGV2aWNlc1tpXS50b3RhbF9z ZWdtZW50czsKPiArCQkJfQo+ICAJCX0KPiAgCQlpZiAoYy5uZGV2cyA+IDEpIHsKPiAgCQkJc3Ry bmNweSgoY2hhciAqKXNiLT5kZXZzW2ldLnBhdGgsIGMuZGV2aWNlc1tpXS5wYXRoLCBNQVhfUEFU SF9MRU4pOwo+IEBAIC01MzEsMTAgKzU5NCwxNiBAQCBzdGF0aWMgaW50IGYyZnNfcHJlcGFyZV9z dXBlcl9ibG9jayh2b2lkKQo+ICAJaWYgKGMuZmVhdHVyZSAmIEYyRlNfRkVBVFVSRV9MT1NUX0ZP VU5EKQo+ICAJCWMubHBmX2lubyA9IGMubmV4dF9mcmVlX25pZCsrOwo+ICAKPiArCWlmIChjLmFs aWFzZWRfZGV2aWNlcykgewo+ICsJCWMuZmlyc3RfYWxpYXNfaW5vID0gYy5uZXh0X2ZyZWVfbmlk Owo+ICsJCWMubmV4dF9mcmVlX25pZCArPSBjLmFsaWFzZWRfZGV2aWNlczsKPiArCQlhdmFpbF96 b25lcyArPSBjLmFsaWFzZWRfc2VnbWVudHMgLyBjLnNlZ3NfcGVyX3pvbmU7Cj4gKwl9Cj4gKwo+ ICAJaWYgKGMuZmVhdHVyZSAmIEYyRlNfRkVBVFVSRV9STykKPiAtCQlhdmFpbF96b25lcyA9IDI7 Cj4gKwkJYXZhaWxfem9uZXMgKz0gMjsKPiAgCWVsc2UKPiAtCQlhdmFpbF96b25lcyA9IDY7Cj4g KwkJYXZhaWxfem9uZXMgKz0gNjsKPiAgCj4gIAlpZiAodG90YWxfem9uZXMgPD0gYXZhaWxfem9u ZXMpIHsKPiAgCQlNU0coMSwgIlx0RXJyb3I6ICVkIHpvbmVzOiBOZWVkIG1vcmUgem9uZXMgIgo+ IEBAIC03MDEsNiArNzcwLDcgQEAgc3RhdGljIGludCBmMmZzX3dyaXRlX2NoZWNrX3BvaW50X3Bh Y2sodm9pZCkKPiAgCWNoYXIgKnN1bV9jb21wYWN0LCAqc3VtX2NvbXBhY3RfcDsKPiAgCXN0cnVj dCBmMmZzX3N1bW1hcnkgKnN1bV9lbnRyeTsKPiAgCXVuc2lnbmVkIHNob3J0IHZibG9ja3M7Cj4g Kwl1aW50MzJfdCB1c2VkX3NlZ21lbnRzID0gYy5hbGlhc2VkX3NlZ21lbnRzOwo+ICAJaW50IHJl dCA9IC0xOwo+ICAKPiAgCWNwID0gY2FsbG9jKEYyRlNfQkxLU0laRSwgMSk7Cj4gQEAgLTc1Miw5 ICs4MjIsMTQgQEAgc3RhdGljIGludCBmMmZzX3dyaXRlX2NoZWNrX3BvaW50X3BhY2sodm9pZCkK PiAgCX0KPiAgCj4gIAlzZXRfY3AoY3VyX25vZGVfYmxrb2ZmWzBdLCBjLmN1cnNlZ19vZmZzZXRb Q1VSU0VHX0hPVF9OT0RFXSk7Cj4gKwlzZXRfY3AoY3VyX25vZGVfYmxrb2ZmWzJdLCBjLmN1cnNl Z19vZmZzZXRbQ1VSU0VHX0NPTERfTk9ERV0pOwo+ICAJc2V0X2NwKGN1cl9kYXRhX2Jsa29mZlsw XSwgYy5jdXJzZWdfb2Zmc2V0W0NVUlNFR19IT1RfREFUQV0pOwo+ICsJc2V0X2NwKGN1cl9kYXRh X2Jsa29mZlsyXSwgYy5jdXJzZWdfb2Zmc2V0W0NVUlNFR19DT0xEX0RBVEFdKTsKPiAgCXNldF9j cCh2YWxpZF9ibG9ja19jb3VudCwgYy5jdXJzZWdfb2Zmc2V0W0NVUlNFR19IT1RfTk9ERV0gKwo+ IC0JCQkJCWMuY3Vyc2VnX29mZnNldFtDVVJTRUdfSE9UX0RBVEFdKTsKPiArCQkJYy5jdXJzZWdf b2Zmc2V0W0NVUlNFR19IT1RfREFUQV0gKwo+ICsJCQljLmN1cnNlZ19vZmZzZXRbQ1VSU0VHX0NP TERfTk9ERV0gKwo+ICsJCQljLmN1cnNlZ19vZmZzZXRbQ1VSU0VHX0NPTERfREFUQV0gKwo+ICsJ CQljLmFsaWFzZWRfc2VnbWVudHMgKiBjLmJsa3NfcGVyX3NlZyk7Cj4gIAlzZXRfY3AocnN2ZF9z ZWdtZW50X2NvdW50LCBjLnJlc2VydmVkX3NlZ21lbnRzKTsKPiAgCj4gIAkvKgo+IEBAIC04MDEs MTUgKzg3NiwxNiBAQCBzdGF0aWMgaW50IGYyZnNfd3JpdGVfY2hlY2tfcG9pbnRfcGFjayh2b2lk KQo+ICAJCQkJCWMucmVzZXJ2ZWRfc2VnbWVudHMpOwo+ICAKPiAgCS8qIG1haW4gc2VnbWVudHMg LSByZXNlcnZlZCBzZWdtZW50cyAtIChub2RlICsgZGF0YSBzZWdtZW50cykgKi8KPiAtCWlmIChj LmZlYXR1cmUgJiBGMkZTX0ZFQVRVUkVfUk8pIHsKPiAtCQlzZXRfY3AoZnJlZV9zZWdtZW50X2Nv dW50LCBmMmZzX2dldF91c2FibGVfc2VnbWVudHMoc2IpIC0gMik7Cj4gLQkJc2V0X2NwKHVzZXJf YmxvY2tfY291bnQsICgoZ2V0X2NwKGZyZWVfc2VnbWVudF9jb3VudCkgKyAyIC0KPiAtCQkJZ2V0 X2NwKG92ZXJwcm92X3NlZ21lbnRfY291bnQpKSAqIGMuYmxrc19wZXJfc2VnKSk7Cj4gLQl9IGVs c2Ugewo+IC0JCXNldF9jcChmcmVlX3NlZ21lbnRfY291bnQsIGYyZnNfZ2V0X3VzYWJsZV9zZWdt ZW50cyhzYikgLSA2KTsKPiAtCQlzZXRfY3AodXNlcl9ibG9ja19jb3VudCwgKChnZXRfY3AoZnJl ZV9zZWdtZW50X2NvdW50KSArIDYgLQo+IC0JCQlnZXRfY3Aob3ZlcnByb3Zfc2VnbWVudF9jb3Vu dCkpICogYy5ibGtzX3Blcl9zZWcpKTsKPiAtCX0KPiArCWlmIChjLmZlYXR1cmUgJiBGMkZTX0ZF QVRVUkVfUk8pCj4gKwkJdXNlZF9zZWdtZW50cyArPSAyOwo+ICsJZWxzZQo+ICsJCXVzZWRfc2Vn bWVudHMgKz0gNjsKPiArCj4gKwlzZXRfY3AodXNlcl9ibG9ja19jb3VudCwgKGYyZnNfZ2V0X3Vz YWJsZV9zZWdtZW50cyhzYikgLQo+ICsJCQlnZXRfY3Aob3ZlcnByb3Zfc2VnbWVudF9jb3VudCkp ICogYy5ibGtzX3Blcl9zZWcpOwo+ICsJc2V0X2NwKGZyZWVfc2VnbWVudF9jb3VudCwgZjJmc19n ZXRfdXNhYmxlX3NlZ21lbnRzKHNiKSAtCj4gKwkJCXVzZWRfc2VnbWVudHMpOwo+ICsKPiAgCS8q IGNwIHBhZ2UgKDIpLCBkYXRhIHN1bW1hcmllcyAoMSksIG5vZGUgc3VtbWFyaWVzICgzKSAqLwo+ ICAJc2V0X2NwKGNwX3BhY2tfdG90YWxfYmxvY2tfY291bnQsIDYgKyBnZXRfc2IoY3BfcGF5bG9h ZCkpOwo+ICAJZmxhZ3MgPSBDUF9VTU9VTlRfRkxBRyB8IENQX0NPTVBBQ1RfU1VNX0ZMQUc7Cj4g QEAgLTgyNSw4ICs5MDEsMTAgQEAgc3RhdGljIGludCBmMmZzX3dyaXRlX2NoZWNrX3BvaW50X3Bh Y2sodm9pZCkKPiAgCj4gIAlzZXRfY3AoY2twdF9mbGFncywgZmxhZ3MpOwo+ICAJc2V0X2NwKGNw X3BhY2tfc3RhcnRfc3VtLCAxICsgZ2V0X3NiKGNwX3BheWxvYWQpKTsKPiAtCXNldF9jcCh2YWxp ZF9ub2RlX2NvdW50LCBjLmN1cnNlZ19vZmZzZXRbQ1VSU0VHX0hPVF9OT0RFXSk7Cj4gLQlzZXRf Y3AodmFsaWRfaW5vZGVfY291bnQsIGMuY3Vyc2VnX29mZnNldFtDVVJTRUdfSE9UX05PREVdKTsK PiArCXNldF9jcCh2YWxpZF9ub2RlX2NvdW50LCBjLmN1cnNlZ19vZmZzZXRbQ1VSU0VHX0hPVF9O T0RFXSArCj4gKwkJCWMuY3Vyc2VnX29mZnNldFtDVVJTRUdfQ09MRF9OT0RFXSk7Cj4gKwlzZXRf Y3AodmFsaWRfaW5vZGVfY291bnQsIGMuY3Vyc2VnX29mZnNldFtDVVJTRUdfSE9UX05PREVdICsK PiArCQkJYy5jdXJzZWdfb2Zmc2V0W0NVUlNFR19DT0xEX05PREVdKTsKPiAgCXNldF9jcChuZXh0 X2ZyZWVfbmlkLCBjLm5leHRfZnJlZV9uaWQpOwo+ICAJc2V0X2NwKHNpdF92ZXJfYml0bWFwX2J5 dGVzaXplLCAoKGdldF9zYihzZWdtZW50X2NvdW50X3NpdCkgLyAyKSA8PAo+ICAJCQlnZXRfc2Io bG9nX2Jsb2Nrc19wZXJfc2VnKSkgLyA4KTsKPiBAQCAtOTc0LDkgKzEwNTIsMTIgQEAgc3RhdGlj IGludCBmMmZzX3dyaXRlX2NoZWNrX3BvaW50X3BhY2sodm9pZCkKPiAgCQlnb3RvIGZyZWVfY3Bf cGF5bG9hZDsKPiAgCX0KPiAgCj4gLQkvKiBGaWxsIHNlZ21lbnQgc3VtbWFyeSBmb3IgQ09MRF9O T0RFIHRvIHplcm8uICovCj4gKwkvKiBQcmVwYXJlIGFuZCB3cml0ZSBTZWdtZW50IHN1bW1hcnkg Zm9yIENPTERfTk9ERSAqLwo+ICAJbWVtc2V0KHN1bSwgMCwgRjJGU19CTEtTSVpFKTsKPiAgCVNF VF9TVU1fVFlQRShzdW0sIFNVTV9UWVBFX05PREUpOwo+ICsJbWVtY3B5KHN1bS0+ZW50cmllcywg Yy5zdW1bQ1VSU0VHX0NPTERfTk9ERV0sCj4gKwkJCXNpemVvZihzdHJ1Y3QgZjJmc19zdW1tYXJ5 KSAqIE1BWF9DQUNIRV9TVU1TKTsKPiArCj4gIAljcF9zZWdfYmxrKys7Cj4gIAlEQkcoMSwgIlx0 V3JpdGluZyBTZWdtZW50IHN1bW1hcnkgZm9yIENPTERfTk9ERSwgYXQgb2Zmc2V0IDB4JTA4IlBS SXg2NCJcbiIsCj4gIAkJCWNwX3NlZ19ibGspOwo+IEBAIC0xMjA5LDEwICsxMjkwLDQwIEBAIHZv aWQgdXBkYXRlX3N1bW1hcnlfZW50cnkoaW50IGN1cnNlZ190eXBlLCBuaWRfdCBuaWQsCj4gIAlz dW0tPm9mc19pbl9ub2RlID0gY3B1X3RvX2xlMTYob2ZzX2luX25vZGUpOwo+ICB9Cj4gIAo+ICtz dGF0aWMgdm9pZCBhZGRfZGVudHJ5KHN0cnVjdCBmMmZzX2RlbnRyeV9ibG9jayAqZGVudF9ibGss IHVuc2lnbmVkIGludCAqZGlkeCwKPiArCQljb25zdCBjaGFyICpuYW1lLCB1aW50MzJfdCBpbm8s IHU4IHR5cGUpCj4gK3sKPiArCWludCBsZW4gPSBzdHJsZW4obmFtZSk7Cj4gKwlmMmZzX2hhc2hf dCBoYXNoOwo+ICsKPiArCWlmIChuYW1lWzBdID09ICcuJyAmJiAobGVuID09IDEgfHwgKGxlbiA9 PSAyICYmIG5hbWVbMV0gPT0gJy4nKSkpCj4gKwkJaGFzaCA9IDA7Cj4gKwllbHNlCj4gKwkJaGFz aCA9IGYyZnNfZGVudHJ5X2hhc2goMCwgMCwgKHVuc2lnbmVkIGNoYXIgKiluYW1lLCBsZW4pOwo+ ICsKPiArCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2JsaywgKmRpZHgpLmhhc2hfY29k ZSA9IGNwdV90b19sZTMyKGhhc2gpOwo+ICsJRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRf YmxrLCAqZGlkeCkuaW5vID0gY3B1X3RvX2xlMzIoaW5vKTsKPiArCUYyRlNfREVOVFJZX0JMT0NL X0RFTlRSWShkZW50X2JsaywgKmRpZHgpLm5hbWVfbGVuID0gY3B1X3RvX2xlMTYobGVuKTsKPiAr CUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2JsaywgKmRpZHgpLmZpbGVfdHlwZSA9IHR5 cGU7Cj4gKwo+ICsJd2hpbGUgKGxlbiA+IEYyRlNfU0xPVF9MRU4pIHsKPiArCQltZW1jcHkoRjJG U19ERU5UUllfQkxPQ0tfRklMRU5BTUUoZGVudF9ibGssICpkaWR4KSwgbmFtZSwKPiArCQkJCUYy RlNfU0xPVF9MRU4pOwo+ICsJCXRlc3RfYW5kX3NldF9iaXRfbGUoKmRpZHgsIGRlbnRfYmxrLT5k ZW50cnlfYml0bWFwKTsKPiArCQlsZW4gLT0gKGludClGMkZTX1NMT1RfTEVOOwo+ICsJCW5hbWUg Kz0gRjJGU19TTE9UX0xFTjsKPiArCQkoKmRpZHgpKys7Cj4gKwl9Cj4gKwltZW1jcHkoRjJGU19E RU5UUllfQkxPQ0tfRklMRU5BTUUoZGVudF9ibGssICpkaWR4KSwgbmFtZSwgbGVuKTsKPiArCXRl c3RfYW5kX3NldF9iaXRfbGUoKmRpZHgsIGRlbnRfYmxrLT5kZW50cnlfYml0bWFwKTsKPiArCSgq ZGlkeCkrKzsKPiArfQo+ICsKPiAgc3RhdGljIGJsb2NrX3QgZjJmc19hZGRfZGVmYXVsdF9kZW50 cnlfcm9vdCh2b2lkKQo+ICB7Cj4gIAlzdHJ1Y3QgZjJmc19kZW50cnlfYmxvY2sgKmRlbnRfYmxr ID0gTlVMTDsKPiAgCWJsb2NrX3QgZGF0YV9ibGthZGRyOwo+ICsJdW5zaWduZWQgaW50IGRpZHgg PSAwOwo+ICAKPiAgCWRlbnRfYmxrID0gY2FsbG9jKEYyRlNfQkxLU0laRSwgMSk7Cj4gIAlpZihk ZW50X2JsayA9PSBOVUxMKSB7Cj4gQEAgLTEyMjAsMzcgKzEzMzEsMjYgQEAgc3RhdGljIGJsb2Nr X3QgZjJmc19hZGRfZGVmYXVsdF9kZW50cnlfcm9vdCh2b2lkKQo+ICAJCXJldHVybiAwOwo+ICAJ fQo+ICAKPiAtCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2JsaywgMCkuaGFzaF9jb2Rl ID0gMDsKPiAtCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2JsaywgMCkuaW5vID0gc2It PnJvb3RfaW5vOwo+IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAwKS5uYW1l X2xlbiA9IGNwdV90b19sZTE2KDEpOwo+IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRf YmxrLCAwKS5maWxlX3R5cGUgPSBGMkZTX0ZUX0RJUjsKPiAtCW1lbWNweShGMkZTX0RFTlRSWV9C TE9DS19GSUxFTkFNRShkZW50X2JsaywgMCksICIuIiwgMSk7Cj4gKwlhZGRfZGVudHJ5KGRlbnRf YmxrLCAmZGlkeCwgIi4iLAo+ICsJCQlsZTMyX3RvX2NwdShzYi0+cm9vdF9pbm8pLCBGMkZTX0ZU X0RJUik7Cj4gKwlhZGRfZGVudHJ5KGRlbnRfYmxrLCAmZGlkeCwgIi4uIiwKPiArCQkJbGUzMl90 b19jcHUoc2ItPnJvb3RfaW5vKSwgRjJGU19GVF9ESVIpOwo+ICAKPiAtCUYyRlNfREVOVFJZX0JM T0NLX0RFTlRSWShkZW50X2JsaywgMSkuaGFzaF9jb2RlID0gMDsKPiAtCUYyRlNfREVOVFJZX0JM T0NLX0RFTlRSWShkZW50X2JsaywgMSkuaW5vID0gc2ItPnJvb3RfaW5vOwo+IC0JRjJGU19ERU5U UllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAxKS5uYW1lX2xlbiA9IGNwdV90b19sZTE2KDIpOwo+ IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAxKS5maWxlX3R5cGUgPSBGMkZT X0ZUX0RJUjsKPiAtCW1lbWNweShGMkZTX0RFTlRSWV9CTE9DS19GSUxFTkFNRShkZW50X2Jsaywg MSksICIuLiIsIDIpOwo+IC0KPiAtCS8qIGJpdG1hcCBmb3IgLiBhbmQgLi4gKi8KPiAtCXRlc3Rf YW5kX3NldF9iaXRfbGUoMCwgZGVudF9ibGstPmRlbnRyeV9iaXRtYXApOwo+IC0JdGVzdF9hbmRf c2V0X2JpdF9sZSgxLCBkZW50X2Jsay0+ZGVudHJ5X2JpdG1hcCk7Cj4gLQo+IC0JaWYgKGMubHBm X2lubykgewo+IC0JCWludCBsZW4gPSBzdHJsZW4oTFBGKTsKPiAtCQlmMmZzX2hhc2hfdCBoYXNo ID0gZjJmc19kZW50cnlfaGFzaCgwLCAwLCAodW5zaWduZWQgY2hhciAqKUxQRiwgbGVuKTsKPiAr CWlmIChjLmxwZl9pbm8pCj4gKwkJYWRkX2RlbnRyeShkZW50X2JsaywgJmRpZHgsIExQRiwgYy5s cGZfaW5vLCBGMkZTX0ZUX0RJUik7Cj4gIAo+IC0JCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShk ZW50X2JsaywgMikuaGFzaF9jb2RlID0gY3B1X3RvX2xlMzIoaGFzaCk7Cj4gLQkJRjJGU19ERU5U UllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAyKS5pbm8gPSBjcHVfdG9fbGUzMihjLmxwZl9pbm8p Owo+IC0JCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2JsaywgMikubmFtZV9sZW4gPSBj cHVfdG9fbGUxNihsZW4pOwo+IC0JCUYyRlNfREVOVFJZX0JMT0NLX0RFTlRSWShkZW50X2Jsaywg MikuZmlsZV90eXBlID0gRjJGU19GVF9ESVI7Cj4gLQkJbWVtY3B5KEYyRlNfREVOVFJZX0JMT0NL X0ZJTEVOQU1FKGRlbnRfYmxrLCAyKSwgTFBGLCBGMkZTX1NMT1RfTEVOKTsKPiArCWlmIChjLmFs aWFzZWRfZGV2aWNlcykgewo+ICsJCWludCBpLCBkZXZfb2ZmID0gMDsKPiAgCj4gLQkJbWVtY3B5 KEYyRlNfREVOVFJZX0JMT0NLX0ZJTEVOQU1FKGRlbnRfYmxrLCAzKSwgJkxQRltGMkZTX1NMT1Rf TEVOXSwKPiAtCQkJCWxlbiAtIEYyRlNfU0xPVF9MRU4pOwo+ICsJCWZvciAoaSA9IDE7IGkgPCBj Lm5kZXZzOyBpKyspIHsKPiArCQkJaWYgKCFkZXZpY2VfaXNfYWxpYXNlZChpKSkKPiArCQkJCWNv bnRpbnVlOwo+ICAKPiAtCQl0ZXN0X2FuZF9zZXRfYml0X2xlKDIsIGRlbnRfYmxrLT5kZW50cnlf Yml0bWFwKTsKPiAtCQl0ZXN0X2FuZF9zZXRfYml0X2xlKDMsIGRlbnRfYmxrLT5kZW50cnlfYml0 bWFwKTsKPiArCQkJYWRkX2RlbnRyeShkZW50X2JsaywgJmRpZHgsIGMuZGV2aWNlc1tpXS5hbGlh c19maWxlbmFtZSwKPiArCQkJCQljLmZpcnN0X2FsaWFzX2lubyArIGRldl9vZmYsCj4gKwkJCQkJ RjJGU19GVF9SRUdfRklMRSk7Cj4gKwkJCWRldl9vZmYrKzsKPiArCQl9Cj4gIAl9Cj4gIAo+ICAJ ZGF0YV9ibGthZGRyID0gYWxsb2NfbmV4dF9mcmVlX2Jsb2NrKENVUlNFR19IT1RfREFUQSk7Cj4g QEAgLTEzMjMsNiArMTQyMyw3IEBAIHN0YXRpYyBpbnQgZjJmc193cml0ZV9kZWZhdWx0X3F1b3Rh KGludCBxdHlwZSwgX19sZTMyIHJhd19pZCkKPiAgCXN0cnVjdCB2Ml9kaXNrX2RxaW5mbyBkZHFp bmZvOwo+ICAJc3RydWN0IHYycjFfZGlza19kcWJsayBkcWJsazsKPiAgCWJsb2NrX3QgYmxrYWRk cjsKPiArCXVpbnQ2NF90IGljbnQgPSAxLCBiY250ID0gMTsKPiAgCWludCBpOwo+ICAKPiAgCWlm IChmaWxlYnVmID09IE5VTEwpIHsKPiBAQCAtMTM1OCwxNiArMTQ1OSwxOCBAQCBzdGF0aWMgaW50 IGYyZnNfd3JpdGVfZGVmYXVsdF9xdW90YShpbnQgcXR5cGUsIF9fbGUzMiByYXdfaWQpCj4gIAlk cWJsay5kcWJfcGFkID0gY3B1X3RvX2xlMzIoMCk7Cj4gIAlkcWJsay5kcWJfaWhhcmRsaW1pdCA9 IGNwdV90b19sZTY0KDApOwo+ICAJZHFibGsuZHFiX2lzb2Z0bGltaXQgPSBjcHVfdG9fbGU2NCgw KTsKPiAtCWlmIChjLmxwZl9pbm8pCj4gLQkJZHFibGsuZHFiX2N1cmlub2RlcyA9IGNwdV90b19s ZTY0KDIpOwo+IC0JZWxzZQo+IC0JCWRxYmxrLmRxYl9jdXJpbm9kZXMgPSBjcHVfdG9fbGU2NCgx KTsKPiArCWlmIChjLmxwZl9pbm8pIHsKPiArCQlpY250Kys7Cj4gKwkJYmNudCsrOwo+ICsJfQo+ ICsJaWYgKGMuYWxpYXNlZF9kZXZpY2VzKSB7Cj4gKwkJaWNudCArPSBjLmFsaWFzZWRfZGV2aWNl czsKPiArCQliY250ICs9IGMuYWxpYXNlZF9zZWdtZW50cyAqIGMuYmxrc19wZXJfc2VnOwo+ICsJ fQo+ICsJZHFibGsuZHFiX2N1cmlub2RlcyA9IGNwdV90b19sZTY0KGljbnQpOwo+ICAJZHFibGsu ZHFiX2JoYXJkbGltaXQgPSBjcHVfdG9fbGU2NCgwKTsKPiAgCWRxYmxrLmRxYl9ic29mdGxpbWl0 ID0gY3B1X3RvX2xlNjQoMCk7Cj4gLQlpZiAoYy5scGZfaW5vKQo+IC0JCWRxYmxrLmRxYl9jdXJz cGFjZSA9IGNwdV90b19sZTY0KEYyRlNfQkxLU0laRSAqIDIpOwo+IC0JZWxzZQo+IC0JCWRxYmxr LmRxYl9jdXJzcGFjZSA9IGNwdV90b19sZTY0KEYyRlNfQkxLU0laRSk7Cj4gKwlkcWJsay5kcWJf Y3Vyc3BhY2UgPSBjcHVfdG9fbGU2NChGMkZTX0JMS1NJWkUgKiBiY250KTsKPiAgCWRxYmxrLmRx Yl9idGltZSA9IGNwdV90b19sZTY0KDApOwo+ICAJZHFibGsuZHFiX2l0aW1lID0gY3B1X3RvX2xl NjQoMCk7Cj4gIAo+IEBAIC0xNDkwLDYgKzE1OTMsNyBAQCBzdGF0aWMgYmxvY2tfdCBmMmZzX2Fk ZF9kZWZhdWx0X2RlbnRyeV9scGYodm9pZCkKPiAgewo+ICAJc3RydWN0IGYyZnNfZGVudHJ5X2Js b2NrICpkZW50X2JsazsKPiAgCWJsb2NrX3QgZGF0YV9ibGthZGRyOwo+ICsJdW5zaWduZWQgaW50 IGRpZHggPSAwOwo+ICAKPiAgCWRlbnRfYmxrID0gY2FsbG9jKEYyRlNfQkxLU0laRSwgMSk7Cj4g IAlpZiAoZGVudF9ibGsgPT0gTlVMTCkgewo+IEBAIC0xNDk3LDIwICsxNjAxLDggQEAgc3RhdGlj IGJsb2NrX3QgZjJmc19hZGRfZGVmYXVsdF9kZW50cnlfbHBmKHZvaWQpCj4gIAkJcmV0dXJuIDA7 Cj4gIAl9Cj4gIAo+IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAwKS5oYXNo X2NvZGUgPSAwOwo+IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAwKS5pbm8g PSBjcHVfdG9fbGUzMihjLmxwZl9pbm8pOwo+IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRl bnRfYmxrLCAwKS5uYW1lX2xlbiA9IGNwdV90b19sZTE2KDEpOwo+IC0JRjJGU19ERU5UUllfQkxP Q0tfREVOVFJZKGRlbnRfYmxrLCAwKS5maWxlX3R5cGUgPSBGMkZTX0ZUX0RJUjsKPiAtCW1lbWNw eShGMkZTX0RFTlRSWV9CTE9DS19GSUxFTkFNRShkZW50X2JsaywgMCksICIuIiwgMSk7Cj4gLQo+ IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAxKS5oYXNoX2NvZGUgPSAwOwo+ IC0JRjJGU19ERU5UUllfQkxPQ0tfREVOVFJZKGRlbnRfYmxrLCAxKS5pbm8gPSBzYi0+cm9vdF9p bm87Cj4gLQlGMkZTX0RFTlRSWV9CTE9DS19ERU5UUlkoZGVudF9ibGssIDEpLm5hbWVfbGVuID0g Y3B1X3RvX2xlMTYoMik7Cj4gLQlGMkZTX0RFTlRSWV9CTE9DS19ERU5UUlkoZGVudF9ibGssIDEp LmZpbGVfdHlwZSA9IEYyRlNfRlRfRElSOwo+IC0JbWVtY3B5KEYyRlNfREVOVFJZX0JMT0NLX0ZJ TEVOQU1FKGRlbnRfYmxrLCAxKSwgIi4uIiwgMik7Cj4gLQo+IC0JdGVzdF9hbmRfc2V0X2JpdF9s ZSgwLCBkZW50X2Jsay0+ZGVudHJ5X2JpdG1hcCk7Cj4gLQl0ZXN0X2FuZF9zZXRfYml0X2xlKDEs IGRlbnRfYmxrLT5kZW50cnlfYml0bWFwKTsKPiArCWFkZF9kZW50cnkoZGVudF9ibGssICZkaWR4 LCAiLiIsIGMubHBmX2lubywgRjJGU19GVF9ESVIpOwo+ICsJYWRkX2RlbnRyeShkZW50X2Jsaywg JmRpZHgsICIuLiIsIGMubHBmX2lubywgRjJGU19GVF9ESVIpOwo+ICAKPiAgCWRhdGFfYmxrYWRk ciA9IGFsbG9jX25leHRfZnJlZV9ibG9jayhDVVJTRUdfSE9UX0RBVEEpOwo+ICAKPiBAQCAtMTU3 OCw2ICsxNjcwLDEwNCBAQCBleGl0Ogo+ICAJcmV0dXJuIGVycjsKPiAgfQo+ICAKPiArc3RhdGlj IHZvaWQgYWxsb2NhdGVfYmxvY2tzX2Zvcl9hbGlhc2VkX2RldmljZShzdHJ1Y3QgZjJmc19ub2Rl ICpyYXdfbm9kZSwKPiArCQl1bnNpZ25lZCBpbnQgZGV2X251bSkKPiArewo+ICsJdWludDMyX3Qg c3RhcnRfc2Vnbm8gPSAoYy5kZXZpY2VzW2Rldl9udW1dLnN0YXJ0X2Jsa2FkZHIgLQo+ICsJCQln ZXRfc2IobWFpbl9ibGthZGRyKSkgLyBjLmJsa3NfcGVyX3NlZzsKPiArCXVpbnQzMl90IGVuZF9z ZWdubyA9IChjLmRldmljZXNbZGV2X251bV0uZW5kX2Jsa2FkZHIgLQo+ICsJCQlnZXRfc2IobWFp bl9ibGthZGRyKSArIDEpIC8gYy5ibGtzX3Blcl9zZWc7Cj4gKwl1aW50MzJfdCBzZWdubzsKPiAr CXVpbnQ2NF90IGJsa2NudDsKPiArCXN0cnVjdCBmMmZzX3NpdF9ibG9jayAqc2l0X2JsayA9IGNh bGxvYyhGMkZTX0JMS1NJWkUsIDEpOwo+ICsKPiArCUFTU0VSVChzaXRfYmxrKTsKPiArCj4gKwlm b3IgKHNlZ25vID0gc3RhcnRfc2Vnbm87IHNlZ25vIDwgZW5kX3NlZ25vOyBzZWdubysrKSB7Cj4g KwkJc3RydWN0IGYyZnNfc2l0X2VudHJ5ICpzaXQ7Cj4gKwkJdWludDY0X3Qgc2l0X2Jsa19hZGRy ID0gZ2V0X3NiKHNpdF9ibGthZGRyKSArCj4gKwkJCShzZWdubyAvIFNJVF9FTlRSWV9QRVJfQkxP Q0spOwo+ICsKPiArCQlBU1NFUlQoZGV2X3JlYWRfYmxvY2soc2l0X2Jsaywgc2l0X2Jsa19hZGRy KSA+PSAwKTsKPiArCQlzaXQgPSAmc2l0X2Jsay0+ZW50cmllc1tzZWdubyAlIFNJVF9FTlRSWV9Q RVJfQkxPQ0tdOwo+ICsJCW1lbXNldCgmc2l0LT52YWxpZF9tYXAsIDB4RkYsIFNJVF9WQkxPQ0tf TUFQX1NJWkUpOwo+ICsJCXNpdC0+dmJsb2NrcyA9IGNwdV90b19sZTE2KChDVVJTRUdfQ09MRF9E QVRBIDw8Cj4gKwkJCQkJU0lUX1ZCTE9DS1NfU0hJRlQpIHwgYy5ibGtzX3Blcl9zZWcpOwo+ICsJ CXNpdC0+bXRpbWUgPSBjcHVfdG9fbGU2NChta2ZzX3RpbWUpOwo+ICsJCUFTU0VSVChkZXZfd3Jp dGVfYmxvY2soc2l0X2Jsaywgc2l0X2Jsa19hZGRyKSA+PSAwKTsKPiArCX0KPiArCj4gKwlibGtj bnQgPSAoZW5kX3NlZ25vIC0gc3RhcnRfc2Vnbm8pICogYy5ibGtzX3Blcl9zZWc7Cj4gKwlyYXdf bm9kZS0+aS5pX3NpemUgPSBjcHVfdG9fbGU2NChibGtjbnQgPDwgZ2V0X3NiKGxvZ19ibG9ja3Np emUpKTsKPiArCXJhd19ub2RlLT5pLmlfYmxvY2tzID0gY3B1X3RvX2xlNjQoYmxrY250ICsgMSk7 Cj4gKwo+ICsJcmF3X25vZGUtPmkuaV9leHQuZm9mcyA9IGNwdV90b19sZTMyKDApOwo+ICsJcmF3 X25vZGUtPmkuaV9leHQuYmxrX2FkZHIgPQo+ICsJCWNwdV90b19sZTMyKGMuZGV2aWNlc1tkZXZf bnVtXS5zdGFydF9ibGthZGRyKTsKPiArCXJhd19ub2RlLT5pLmlfZXh0LmxlbiA9IGNwdV90b19s ZTMyKGJsa2NudCk7Cj4gKwo+ICsJZnJlZShzaXRfYmxrKTsKPiArfQo+ICsKPiArc3RhdGljIGlu dCBmMmZzX3dyaXRlX2FsaWFzX2lub2Rlcyh2b2lkKQo+ICt7Cj4gKwlzdHJ1Y3QgZjJmc19ub2Rl ICpyYXdfbm9kZTsKPiArCWJsb2NrX3Qgbm9kZV9ibGthZGRyOwo+ICsJaW50IGVyciA9IDA7Cj4g Kwl1bnNpZ25lZCBpbnQgaSwgZGV2X29mZiA9IDA7Cj4gKwo+ICsJQVNTRVJUKGMuYWxpYXNlZF9k ZXZpY2VzKTsKPiArCj4gKwlyYXdfbm9kZSA9IGNhbGxvYyhGMkZTX0JMS1NJWkUsIDEpOwo+ICsJ aWYgKHJhd19ub2RlID09IE5VTEwpIHsKPiArCQlNU0coMSwgIlx0RXJyb3I6IENhbGxvYyBGYWls ZWQgZm9yIHJhd19ub2RlISEhXG4iKTsKPiArCQlyZXR1cm4gLTE7Cj4gKwl9Cj4gKwo+ICsJZm9y IChpID0gMTsgaSA8IGMubmRldnM7IGkrKykgewo+ICsJCWNvbnN0IGNoYXIgKmZpbGVuYW1lOwo+ ICsJCW5pZF90IGlubzsKPiArCj4gKwkJaWYgKCFkZXZpY2VfaXNfYWxpYXNlZChpKSkKPiArCQkJ Y29udGludWU7Cj4gKwo+ICsJCWlubyA9IGMuZmlyc3RfYWxpYXNfaW5vICsgZGV2X29mZjsKPiAr CQlkZXZfb2ZmKys7Cj4gKwkJZjJmc19pbml0X2lub2RlKHNiLCByYXdfbm9kZSwgaW5vLCBta2Zz X3RpbWUsIDB4ODFjMCk7Cj4gKwo+ICsJCXJhd19ub2RlLT5pLmlfZmxhZ3MgPSBjcHVfdG9fbGUz MihGMkZTX0lNTVVUQUJMRV9GTCB8Cj4gKwkJCQlGMkZTX0RFVklDRV9BTElBU19GTCk7Cj4gKwkJ cmF3X25vZGUtPmkuaV9pbmxpbmUgPSBGMkZTX1BJTl9GSUxFOwo+ICsJCXJhd19ub2RlLT5pLmlf cGlubyA9IHNiLT5yb290X2lubzsKPiArCQlmaWxlbmFtZSA9IGMuZGV2aWNlc1tpXS5hbGlhc19m aWxlbmFtZTsKPiArCQlyYXdfbm9kZS0+aS5pX25hbWVsZW4gPSBjcHVfdG9fbGUzMihzdHJsZW4o ZmlsZW5hbWUpKTsKPiArCQltZW1jcHkocmF3X25vZGUtPmkuaV9uYW1lLCBmaWxlbmFtZSwgc3Ry bGVuKGZpbGVuYW1lKSk7Cj4gKwo+ICsJCW5vZGVfYmxrYWRkciA9IGFsbG9jX25leHRfZnJlZV9i bG9jayhDVVJTRUdfQ09MRF9OT0RFKTsKPiArCQlGMkZTX05PREVfRk9PVEVSKHJhd19ub2RlKS0+ bmV4dF9ibGthZGRyID0KPiArCQkJY3B1X3RvX2xlMzIobm9kZV9ibGthZGRyICsgMSk7Cj4gKwo+ ICsJCWFsbG9jYXRlX2Jsb2Nrc19mb3JfYWxpYXNlZF9kZXZpY2UocmF3X25vZGUsIGkpOwo+ICsK PiArCQlEQkcoMSwgIlx0V3JpdGluZyBhbGlhc2VkIGRldmljZSBpbm9kZSAoY29sZCBub2RlKSwg Igo+ICsJCQkJIm9mZnNldCAweCV4XG4iLCBub2RlX2Jsa2FkZHIpOwo+ICsJCWlmICh3cml0ZV9p bm9kZShyYXdfbm9kZSwgbm9kZV9ibGthZGRyKSA8IDApIHsKPiArCQkJTVNHKDEsICJcdEVycm9y OiBXaGlsZSB3cml0aW5nIHRoZSByYXdfbm9kZSB0byAiCj4gKwkJCQkJImRpc2shISFcbiIpOwo+ ICsJCQllcnIgPSAtMTsKPiArCQkJZ290byBleGl0Owo+ICsJCX0KPiArCj4gKwkJdXBkYXRlX25h dF9qb3VybmFsKGlubywgbm9kZV9ibGthZGRyKTsKPiArCQl1cGRhdGVfc2l0X2pvdXJuYWwoQ1VS U0VHX0NPTERfTk9ERSk7Cj4gKwkJdXBkYXRlX3N1bW1hcnlfZW50cnkoQ1VSU0VHX0NPTERfTk9E RSwgaW5vLCAwKTsKPiArCX0KPiArCj4gK2V4aXQ6Cj4gKwlmcmVlKHJhd19ub2RlKTsKPiArCXJl dHVybiBlcnI7Cj4gK30KPiArCj4gIHN0YXRpYyBpbnQgZjJmc19jcmVhdGVfcm9vdF9kaXIodm9p ZCkKPiAgewo+ICAJZW51bSBxdW90YV90eXBlIHF0eXBlOwo+IEBAIC0xNjA3LDYgKzE3OTcsMTUg QEAgc3RhdGljIGludCBmMmZzX2NyZWF0ZV9yb290X2Rpcih2b2lkKQo+ICAJCX0KPiAgCX0KPiAg Cj4gKwlpZiAoYy5hbGlhc2VkX2RldmljZXMpIHsKPiArCQllcnIgPSBmMmZzX3dyaXRlX2FsaWFz X2lub2RlcygpOwo+ICsJCWlmIChlcnIgPCAwKSB7Cj4gKwkJCU1TRygxLCAiXHRFcnJvcjogRmFp bGVkIHRvIHdyaXRlIGFsaWFzZWQgZGV2aWNlICIKPiArCQkJCSJpbm9kZXMhISFcbiIpOwo+ICsJ CQlnb3RvIGV4aXQ7Cj4gKwkJfQo+ICsJfQo+ICsKPiAgI2lmbmRlZiBXSVRIX0FORFJPSUQKPiAg CWVyciA9IGYyZnNfZGlzY2FyZF9vYnNvbGV0ZV9kbm9kZSgpOwo+ICAJaWYgKGVyciA8IDApIHsK PiBkaWZmIC0tZ2l0IGEvbWtmcy9mMmZzX2Zvcm1hdF9tYWluLmMgYi9ta2ZzL2YyZnNfZm9ybWF0 X21haW4uYwo+IGluZGV4IDJiYTFjMjEuLmIxMTNiYmMgMTAwNjQ0Cj4gLS0tIGEvbWtmcy9mMmZz X2Zvcm1hdF9tYWluLmMKPiArKysgYi9ta2ZzL2YyZnNfZm9ybWF0X21haW4uYwo+IEBAIC01MCw3 ICs1MCw3IEBAIHN0YXRpYyB2b2lkIG1rZnNfdXNhZ2UoKQo+ICAJTVNHKDAsICJcblVzYWdlOiBt a2ZzLmYyZnMgW29wdGlvbnNdIGRldmljZSBbc2VjdG9yc11cbiIpOwo+ICAJTVNHKDAsICJbb3B0 aW9uc106XG4iKTsKPiAgCU1TRygwLCAiICAtYiBmaWxlc3lzdGVtIGJsb2NrIHNpemUgW2RlZmF1 bHQ6NDA5Nl1cbiIpOwo+IC0JTVNHKDAsICIgIC1jIFtkZXZpY2VfbmFtZV0gdXAgdG8gNyBhZGRp dGlvbmFsIGRldmljZXMsIGV4Y2VwdCBtZXRhIGRldmljZVxuIik7Cj4gKwlNU0coMCwgIiAgLWMg W2RldmljZV9uYW1lW0BhbGlhc19maWxlbmFtZV1dIHVwIHRvIDcgYWRkaXRpb25hbCBkZXZpY2Vz LCBleGNlcHQgbWV0YSBkZXZpY2VcbiIpOwo+ICAJTVNHKDAsICIgIC1kIGRlYnVnIGxldmVsIFtk ZWZhdWx0OjBdXG4iKTsKPiAgCU1TRygwLCAiICAtZSBbY29sZCBmaWxlIGV4dCBsaXN0XSBlLmcu IFwibXAzLGdpZixtb3ZcIlxuIik7Cj4gIAlNU0coMCwgIiAgLUUgW2hvdCBmaWxlIGV4dCBsaXN0 XSBlLmcuIFwiZGJcIlxuIik7Cj4gQEAgLTEwNSw2ICsxMDUsOSBAQCBzdGF0aWMgdm9pZCBmMmZz X3Nob3dfaW5mbygpCj4gIAo+ICAJaWYgKGMuZmVhdHVyZSAmIEYyRlNfRkVBVFVSRV9DT01QUkVT U0lPTikKPiAgCQlNU0coMCwgIkluZm86IEVuYWJsZSBDb21wcmVzc2lvblxuIik7Cj4gKwo+ICsJ aWYgKGMuZmVhdHVyZSAmIEYyRlNfRkVBVFVSRV9ERVZJQ0VfQUxJQVMpCj4gKwkJTVNHKDAsICJJ bmZvOiBFbmFibGUgZGV2aWNlIGFsaWFzaW5nXG4iKTsKPiAgfQo+ICAKPiAgI2lmIGRlZmluZWQo QU5EUk9JRF9UQVJHRVQpICYmIGRlZmluZWQoSEFWRV9TWVNfVVRTTkFNRV9IKQo+IEBAIC0xODEs NiArMTg0LDcgQEAgc3RhdGljIHZvaWQgZjJmc19wYXJzZV9vcHRpb25zKGludCBhcmdjLCBjaGFy ICphcmd2W10pCj4gIAlpbnQzMl90IG9wdGlvbj0wOwo+ICAJaW50IHZhbDsKPiAgCWNoYXIgKnRv a2VuOwo+ICsJaW50IGRldl9udW07Cj4gIAo+ICAJd2hpbGUgKChvcHRpb24gPSBnZXRvcHRfbG9u ZyhhcmdjLGFyZ3Ysb3B0aW9uX3N0cmluZyxsb25nX29wdHMsTlVMTCkpICE9IEVPRikgewo+ICAJ CXN3aXRjaCAob3B0aW9uKSB7Cj4gQEAgLTIwMCwxNyArMjA0LDM1IEBAIHN0YXRpYyB2b2lkIGYy ZnNfcGFyc2Vfb3B0aW9ucyhpbnQgYXJnYywgY2hhciAqYXJndltdKQo+ICAJCQl9Cj4gIAkJCWJy ZWFrOwo+ICAJCWNhc2UgJ2MnOgo+IC0JCQlpZiAoYy5uZGV2cyA+PSBNQVhfREVWSUNFUykgewo+ ICsJCQlkZXZfbnVtID0gYy5uZGV2czsKPiArCj4gKwkJCWlmIChkZXZfbnVtID49IE1BWF9ERVZJ Q0VTKSB7Cj4gIAkJCQlNU0coMCwgIkVycm9yOiBUb28gbWFueSBkZXZpY2VzXG4iKTsKPiAgCQkJ CW1rZnNfdXNhZ2UoKTsKPiAgCQkJfQo+ICAKPiAtCQkJaWYgKHN0cmxlbihvcHRhcmcpID4gTUFY X1BBVEhfTEVOKSB7Cj4gKwkJCXRva2VuID0gc3RydG9rKG9wdGFyZywgIkAiKTsKPiArCQkJaWYg KHN0cmxlbih0b2tlbikgPiBNQVhfUEFUSF9MRU4pIHsKPiAgCQkJCU1TRygwLCAiRXJyb3I6IGRl dmljZSBwYXRoIHNob3VsZCBiZSBsZXNzIHRoYW4gIgo+ICAJCQkJCSIlZCBjaGFyYWN0ZXJzXG4i LCBNQVhfUEFUSF9MRU4pOwo+ICAJCQkJbWtmc191c2FnZSgpOwo+ICAJCQl9Cj4gLQkJCWMuZGV2 aWNlc1tjLm5kZXZzKytdLnBhdGggPSBzdHJkdXAob3B0YXJnKTsKPiArCQkJYy5kZXZpY2VzW2Rl dl9udW1dLnBhdGggPSBzdHJkdXAodG9rZW4pOwo+ICsJCQl0b2tlbiA9IHN0cnRvayhOVUxMLCAi Iik7Cj4gKwkJCWlmICh0b2tlbikgewo+ICsJCQkJaWYgKHN0cmxlbih0b2tlbikgPiBNQVhfUEFU SF9MRU4pIHsKPiArCQkJCQlNU0coMCwgIkVycm9yOiBhbGlhc19maWxlbmFtZSBzaG91bGQgIgo+ ICsJCQkJCQkiYmUgbGVzcyB0aGFuICVkIGNoYXJhY3RlcnNcbiIsCj4gKwkJCQkJCU1BWF9QQVRI X0xFTik7Cj4gKwkJCQkJbWtmc191c2FnZSgpOwo+ICsJCQkJfQo+ICsJCQkJYy5kZXZpY2VzW2Rl dl9udW1dLmFsaWFzX2ZpbGVuYW1lID0KPiArCQkJCQlzdHJkdXAodG9rZW4pOwo+ICsJCQkJaWYg KCFjLmFsaWFzZWRfZGV2aWNlcykKPiArCQkJCQljLmZlYXR1cmUgfD0gRjJGU19GRUFUVVJFX0RF VklDRV9BTElBUzsKPiArCQkJCWMuYWxpYXNlZF9kZXZpY2VzKys7Cj4gKwkJCX0KPiArCQkJYy5u ZGV2cysrOwo+ICAJCQlicmVhazsKPiAgCQljYXNlICdkJzoKPiAgCQkJYy5kYmdfbHYgPSBhdG9p KG9wdGFyZyk7Cj4gLS0gCj4gMi40Ni4wLjY2Mi5nOTJkMDg4MWJiMC1nb29nCj4gCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtZjJmcy1kZXZl bCBtYWlsaW5nIGxpc3QKTGludXgtZjJmcy1kZXZlbEBsaXN0cy5zb3VyY2Vmb3JnZS5uZXQKaHR0 cHM6Ly9saXN0cy5zb3VyY2Vmb3JnZS5uZXQvbGlzdHMvbGlzdGluZm8vbGludXgtZjJmcy1kZXZl bAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 70AFF175D59 for ; Wed, 18 Sep 2024 23:48:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726703284; cv=none; b=o1lj4flb1Eb/ZW7irfFoIywNOcQJd3nzwAInBP2XaYDSvV8HvvB7WN06Ml0Xwt2AZN2FCUpT4bCSppzgaTEv2WmWPEgyc6JLOGBCzlCBsY4SX/SeaPIwtWz49bI1D+BPR+6o3n+0Gr6mT1qy1kBWjfGleyvleSqWYw2vsC3VuYA= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726703284; c=relaxed/simple; bh=TwjzBhW/KGfbR9I/CrpjTeV730GGiRdHyktigv92gHQ=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=kH4xFaOSrNqTznGSih9jXh0jlvqu2YMgC9oHFaAUowwUMznDfVsN4Xn1WtbkL/+46KZoUBPCM2jAi9oU3r5gLQNylcXguLu7wZbsWUfOQV4woIGnK3D8gp5p/zGuaIMDfaoMG+wCkTrVq8T8ThArlKVox5NjFX/yljrP4qSmhgQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lh/U4Tth; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lh/U4Tth" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9FF05C4CEC2; Wed, 18 Sep 2024 23:48:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1726703283; bh=TwjzBhW/KGfbR9I/CrpjTeV730GGiRdHyktigv92gHQ=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=lh/U4TthaET+jwEuFYI2YfWNgwfmPovPA2j7mb2TuI8v/efBLwloDVs+OC6BbTVTz fZA+zcJtcsrjk0jrblwUP/RY/NN38m9NVFtqsole7TTCYRFzI4Yegzxc6afaTKhb8e lKh4FskhW5dMcDb0PAsJ0dSUZNDBqL7uTL+dtEIngNLAptH8R7TWd3OyIriszozyf8 3OQOB4ssBet9se1zKSmp/v20ZRD5t60ymXIU++j7onVtb0P95RjOsFQqY9f4Diefmk XGvCxJjQDFjJ1O1ZQZIjQVinia8WSpWryD490AmASWjJ+dyF4NhlgB7F3n6IsoSHC3 nAQaY8Ui9I/1g== Date: Wed, 18 Sep 2024 23:48:01 +0000 From: Jaegeuk Kim To: Daeho Jeong Cc: linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, kernel-team@android.com, Daeho Jeong Subject: Re: [PATCH v2 2/2] mkfs.f2fs: add device aliasing feature Message-ID: References: <20240916192014.1611002-1-daeho43@gmail.com> <20240916192014.1611002-2-daeho43@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20240916192014.1611002-2-daeho43@gmail.com> In file included from f2fs_format.c:14: f2fs_format.c: In function ‘allocate_blocks_for_aliased_device’: f2fs_format.c:1705:24: error: too few arguments to function ‘dev_write_block’ 1705 | ASSERT(dev_write_block(sit_blk, sit_blk_addr) >= 0); | ^~~~~~~~~~~~~~~ ../include/f2fs_fs.h:275:23: note: in definition of macro ‘ASSERT’ 275 | if (!(exp)) { \ | ^~~ ../include/f2fs_fs.h:1651:12: note: declared here 1651 | extern int dev_write_block(void *, __u64, enum rw_hint); | ^~~~~~~~~~~~~~~ f2fs_format.c: In function ‘f2fs_write_alias_inodes’: f2fs_format.c:1762:21: error: too few arguments to function ‘write_inode’ 1762 | if (write_inode(raw_node, node_blkaddr) < 0) { | ^~~~~~~~~~~ ../include/f2fs_fs.h:1612:12: note: declared here 1612 | extern int write_inode(struct f2fs_node *, u64, enum rw_hint); | ^~~~~~~~~~~ On 09/16, Daeho Jeong wrote: > From: Daeho Jeong > > We can add a device aliasing file which can map the whole device with an > extent, not using node blocks. This mapped area should be pinned and > normally used for read-only usages. After finished using it, we can > deallocate the whole area and return it back to use it for other files. > > Signed-off-by: Daeho Jeong > --- > v2: removed unnecessary define and renamed IS_ALIASING() > --- > fsck/dump.c | 13 ++ > fsck/fsck.c | 49 ++++-- > fsck/fsck.h | 4 +- > fsck/main.c | 5 + > include/f2fs_fs.h | 7 + > mkfs/f2fs_format.c | 335 ++++++++++++++++++++++++++++++++-------- > mkfs/f2fs_format_main.c | 30 +++- > 7 files changed, 359 insertions(+), 84 deletions(-) > > diff --git a/fsck/dump.c b/fsck/dump.c > index 448c0ef..bd4c7bd 100644 > --- a/fsck/dump.c > +++ b/fsck/dump.c > @@ -527,6 +527,19 @@ static int dump_inode_blk(struct f2fs_sb_info *sbi, u32 nid, > } > > c.show_file_map_max_offset = f2fs_max_file_offset(&node_blk->i); > + > + if (IS_DEVICE_ALIASING(&node_blk->i)) { > + u32 blkaddr = le32_to_cpu(node_blk->i.i_ext.blk_addr); > + u32 len = le32_to_cpu(node_blk->i.i_ext.len); > + u32 idx; > + > + for (idx = 0; idx < len; idx++) > + dump_data_blk(sbi, idx * F2FS_BLKSIZE, blkaddr++, false); > + print_extent(true); > + > + goto dump_xattr; > + } > + > addr_per_block = ADDRS_PER_BLOCK(&node_blk->i); > > /* check data blocks in inode */ > diff --git a/fsck/fsck.c b/fsck/fsck.c > index a18bee9..c9b0f36 100644 > --- a/fsck/fsck.c > +++ b/fsck/fsck.c > @@ -902,6 +902,7 @@ void fsck_chk_inode_blk(struct f2fs_sb_info *sbi, u32 nid, > int need_fix = 0; > int ret; > u32 cluster_size = 1 << node_blk->i.i_log_cluster_size; > + bool is_aliasing = IS_DEVICE_ALIASING(&node_blk->i); > > if (!compressed) > goto check_next; > @@ -1132,6 +1133,33 @@ check_next: > addrs_per_blk * NIDS_PER_BLOCK * > NIDS_PER_BLOCK) * F2FS_BLKSIZE; > } > + > + if (is_aliasing) { > + struct extent_info ei; > + > + get_extent_info(&ei, &node_blk->i.i_ext); > + for (idx = 0; idx < ei.len; idx++, child.pgofs++) { > + block_t blkaddr = ei.blk + idx; > + > + /* check extent info */ > + check_extent_info(&child, blkaddr, 0); > + ret = fsck_chk_data_blk(sbi, &node_blk->i, blkaddr, > + &child, (i_blocks == *blk_cnt), ftype, nid, > + idx, ni->version, node_blk); > + if (!ret) { > + *blk_cnt = *blk_cnt + 1; > + if (cur_qtype != -1) > + qf_last_blkofs[cur_qtype] = child.pgofs; > + } else if (c.fix_on) { > + node_blk->i.i_ext.len = cpu_to_le32(idx); > + need_fix = 1; > + break; > + } > + } > + > + goto check; > + } > + > for (idx = 0; idx < addrs; idx++, child.pgofs++) { > block_t blkaddr = le32_to_cpu(node_blk->i.i_addr[ofs + idx]); > > @@ -1164,11 +1192,11 @@ check_next: > child.pgofs - cbc->cheader_pgofs < cluster_size) > cbc->cnt++; > ret = fsck_chk_data_blk(sbi, > - IS_CASEFOLDED(&node_blk->i), > + &node_blk->i, > blkaddr, > &child, (i_blocks == *blk_cnt), > ftype, nid, idx, ni->version, > - file_is_encrypt(&node_blk->i), node_blk); > + node_blk); > if (blkaddr != le32_to_cpu(node_blk->i.i_addr[ofs + idx])) > need_fix = 1; > if (!ret) { > @@ -1362,7 +1390,7 @@ skip_blkcnt_fix: > } > > /* drop extent information to avoid potential wrong access */ > - if (need_fix && f2fs_dev_is_writable()) > + if (need_fix && f2fs_dev_is_writable() && !is_aliasing) > node_blk->i.i_ext.len = 0; > > if ((c.feature & F2FS_FEATURE_INODE_CHKSUM) && > @@ -1436,11 +1464,9 @@ int fsck_chk_dnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, > if (!compr_rel && blkaddr == NEW_ADDR && child->pgofs - > cbc->cheader_pgofs < cluster_size) > cbc->cnt++; > - ret = fsck_chk_data_blk(sbi, IS_CASEFOLDED(inode), > - blkaddr, child, > + ret = fsck_chk_data_blk(sbi, inode, blkaddr, child, > le64_to_cpu(inode->i_blocks) == *blk_cnt, ftype, > - nid, idx, ni->version, > - file_is_encrypt(inode), node_blk); > + nid, idx, ni->version, node_blk); > if (blkaddr != le32_to_cpu(node_blk->dn.addr[idx])) > need_fix = 1; > if (!ret) { > @@ -2044,12 +2070,15 @@ int fsck_chk_dentry_blk(struct f2fs_sb_info *sbi, int casefolded, u32 blk_addr, > return 0; > } > > -int fsck_chk_data_blk(struct f2fs_sb_info *sbi, int casefolded, > +int fsck_chk_data_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, > u32 blk_addr, struct child_info *child, int last_blk, > enum FILE_TYPE ftype, u32 parent_nid, u16 idx_in_node, u8 ver, > - int enc_name, struct f2fs_node *node_blk) > + struct f2fs_node *node_blk) > { > struct f2fs_fsck *fsck = F2FS_FSCK(sbi); > + int casefolded = IS_CASEFOLDED(inode); > + int enc_name = file_is_encrypt(inode); > + int aliasing = IS_DEVICE_ALIASING(inode); > > /* Is it reserved block? */ > if (blk_addr == NEW_ADDR) { > @@ -2062,7 +2091,7 @@ int fsck_chk_data_blk(struct f2fs_sb_info *sbi, int casefolded, > return -EINVAL; > } > > - if (is_valid_ssa_data_blk(sbi, blk_addr, parent_nid, > + if (!aliasing && is_valid_ssa_data_blk(sbi, blk_addr, parent_nid, > idx_in_node, ver)) { > ASSERT_MSG("summary data block is not valid. [0x%x]", > parent_nid); > diff --git a/fsck/fsck.h b/fsck/fsck.h > index a8f187e..a2625ef 100644 > --- a/fsck/fsck.h > +++ b/fsck/fsck.h > @@ -179,9 +179,9 @@ extern int fsck_chk_idnode_blk(struct f2fs_sb_info *, struct f2fs_inode *, > extern int fsck_chk_didnode_blk(struct f2fs_sb_info *, struct f2fs_inode *, > enum FILE_TYPE, struct f2fs_node *, u32 *, > struct f2fs_compr_blk_cnt *, struct child_info *); > -extern int fsck_chk_data_blk(struct f2fs_sb_info *, int, > +extern int fsck_chk_data_blk(struct f2fs_sb_info *, struct f2fs_inode *, > u32, struct child_info *, int, enum FILE_TYPE, u32, u16, u8, > - int, struct f2fs_node *); > + struct f2fs_node *); > extern int fsck_chk_dentry_blk(struct f2fs_sb_info *, int, > u32, struct child_info *, int, int, struct f2fs_node *); > int fsck_chk_inline_dentries(struct f2fs_sb_info *, struct f2fs_node *, > diff --git a/fsck/main.c b/fsck/main.c > index 8881936..9dd834f 100644 > --- a/fsck/main.c > +++ b/fsck/main.c > @@ -1015,6 +1015,11 @@ static int do_defrag(struct f2fs_sb_info *sbi) > return -1; > } > > + if (get_sb(feature) & F2FS_FEATURE_DEVICE_ALIAS) { > + MSG(0, "Not support on image with device aliasing feature.\n"); > + return -1; > + } > + > if (c.defrag_start > get_sb(block_count)) > goto out_range; > if (c.defrag_start < SM_I(sbi)->main_blkaddr) > diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h > index 15a1c82..a8380df 100644 > --- a/include/f2fs_fs.h > +++ b/include/f2fs_fs.h > @@ -444,6 +444,7 @@ struct device_info { > uint64_t start_blkaddr; > uint64_t end_blkaddr; > uint32_t total_segments; > + char *alias_filename; > > /* to handle zone block devices */ > int zoned_model; > @@ -666,6 +667,8 @@ enum { > #define F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */ > #define F2FS_NOATIME_FL 0x00000080 /* do not update atime */ > #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */ > +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */ > +#define IS_DEVICE_ALIASING(fi) ((fi)->i_flags & cpu_to_le32(F2FS_DEVICE_ALIAS_FL)) > > #define F2FS_ENC_UTF8_12_1 1 > #define F2FS_ENC_STRICT_MODE_FL (1 << 0) > @@ -698,6 +701,7 @@ enum { > #define F2FS_FEATURE_CASEFOLD 0x1000 > #define F2FS_FEATURE_COMPRESSION 0x2000 > #define F2FS_FEATURE_RO 0x4000 > +#define F2FS_FEATURE_DEVICE_ALIAS 0x8000 > > #define MAX_NR_FEATURE 32 > > @@ -1520,11 +1524,14 @@ struct f2fs_configuration { > time_t fixed_time; > int roll_forward; > bool need_fsync; > + int aliased_devices; > + uint32_t aliased_segments; > > /* mkfs parameters */ > int fake_seed; > uint32_t next_free_nid; > uint32_t lpf_ino; > + uint32_t first_alias_ino; > uint32_t root_uid; > uint32_t root_gid; > uint32_t blksize; > diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c > index 247a836..80b140f 100644 > --- a/mkfs/f2fs_format.c > +++ b/mkfs/f2fs_format.c > @@ -13,6 +13,7 @@ > #include > #include > #include > +#include > > #ifdef HAVE_SYS_STAT_H > #include > @@ -39,10 +40,62 @@ struct f2fs_super_block raw_sb; > struct f2fs_super_block *sb = &raw_sb; > struct f2fs_checkpoint *cp; > > +static inline bool device_is_aliased(unsigned int dev_num) > +{ > + if (dev_num >= c.ndevs) > + return false; > + return c.devices[dev_num].alias_filename != NULL; > +} > + > +static inline unsigned int target_device_index(uint64_t blkaddr) > +{ > + int i; > + > + for (i = 0; i < c.ndevs; i++) > + if (c.devices[i].start_blkaddr <= blkaddr && > + c.devices[i].end_blkaddr >= blkaddr) > + return i; > + return 0; > +} > + > +#define GET_SEGNO(blk_addr) ((blk_addr - get_sb(main_blkaddr)) / \ > + c.blks_per_seg) > +#define START_BLOCK(segno) (segno * c.blks_per_seg + get_sb(main_blkaddr)) > + > /* Return first segment number of each area */ > -#define prev_zone(cur) (c.cur_seg[cur] - c.segs_per_zone) > -#define next_zone(cur) (c.cur_seg[cur] + c.segs_per_zone) > -#define last_zone(cur) ((cur - 1) * c.segs_per_zone) > +static inline uint32_t next_zone(int seg_type) > +{ > + uint32_t next_seg = c.cur_seg[seg_type] + c.segs_per_zone; > + uint64_t next_blkaddr = START_BLOCK(next_seg); > + int dev_num; > + > + dev_num = target_device_index(next_blkaddr); > + if (!device_is_aliased(dev_num)) > + return GET_SEGNO(next_blkaddr); > + > + while (dev_num < c.ndevs && device_is_aliased(dev_num)) > + dev_num++; > + > + return GET_SEGNO(c.devices[dev_num - 1].end_blkaddr + 1); > +} > + > +static inline uint32_t last_zone(uint32_t total_zone) > +{ > + uint32_t last_seg = (total_zone - 1) * c.segs_per_zone; > + uint64_t last_blkaddr = START_BLOCK(last_seg); > + int dev_num; > + > + dev_num = target_device_index(last_blkaddr); > + if (!device_is_aliased(dev_num)) > + return GET_SEGNO(last_blkaddr); > + > + while (dev_num > 0 && device_is_aliased(dev_num)) > + dev_num--; > + > + return GET_SEGNO(c.devices[dev_num + 1].start_blkaddr) - > + c.segs_per_zone; > +} > + > #define last_section(cur) (cur + (c.secs_per_zone - 1) * c.segs_per_sec) > > /* Return time fixed by the user or current time by default */ > @@ -220,7 +273,7 @@ static int f2fs_prepare_super_block(void) > uint64_t total_meta_zones, total_meta_segments; > uint32_t sit_bitmap_size, max_sit_bitmap_size; > uint32_t max_nat_bitmap_size, max_nat_segments; > - uint32_t total_zones, avail_zones; > + uint32_t total_zones, avail_zones = 0; > enum quota_type qtype; > int i; > > @@ -314,6 +367,16 @@ static int f2fs_prepare_super_block(void) > c.devices[i].end_blkaddr = c.devices[i].start_blkaddr + > c.devices[i].total_segments * > c.blks_per_seg - 1; > + if (device_is_aliased(i)) { > + if (c.devices[i].zoned_model == > + F2FS_ZONED_HM) { > + MSG(1, "\tError: do not support " > + "device aliasing for device[%d]\n", i); > + return -1; > + } > + c.aliased_segments += > + c.devices[i].total_segments; > + } > } > if (c.ndevs > 1) { > strncpy((char *)sb->devs[i].path, c.devices[i].path, MAX_PATH_LEN); > @@ -531,10 +594,16 @@ static int f2fs_prepare_super_block(void) > if (c.feature & F2FS_FEATURE_LOST_FOUND) > c.lpf_ino = c.next_free_nid++; > > + if (c.aliased_devices) { > + c.first_alias_ino = c.next_free_nid; > + c.next_free_nid += c.aliased_devices; > + avail_zones += c.aliased_segments / c.segs_per_zone; > + } > + > if (c.feature & F2FS_FEATURE_RO) > - avail_zones = 2; > + avail_zones += 2; > else > - avail_zones = 6; > + avail_zones += 6; > > if (total_zones <= avail_zones) { > MSG(1, "\tError: %d zones: Need more zones " > @@ -701,6 +770,7 @@ static int f2fs_write_check_point_pack(void) > char *sum_compact, *sum_compact_p; > struct f2fs_summary *sum_entry; > unsigned short vblocks; > + uint32_t used_segments = c.aliased_segments; > int ret = -1; > > cp = calloc(F2FS_BLKSIZE, 1); > @@ -752,9 +822,14 @@ static int f2fs_write_check_point_pack(void) > } > > set_cp(cur_node_blkoff[0], c.curseg_offset[CURSEG_HOT_NODE]); > + set_cp(cur_node_blkoff[2], c.curseg_offset[CURSEG_COLD_NODE]); > set_cp(cur_data_blkoff[0], c.curseg_offset[CURSEG_HOT_DATA]); > + set_cp(cur_data_blkoff[2], c.curseg_offset[CURSEG_COLD_DATA]); > set_cp(valid_block_count, c.curseg_offset[CURSEG_HOT_NODE] + > - c.curseg_offset[CURSEG_HOT_DATA]); > + c.curseg_offset[CURSEG_HOT_DATA] + > + c.curseg_offset[CURSEG_COLD_NODE] + > + c.curseg_offset[CURSEG_COLD_DATA] + > + c.aliased_segments * c.blks_per_seg); > set_cp(rsvd_segment_count, c.reserved_segments); > > /* > @@ -801,15 +876,16 @@ static int f2fs_write_check_point_pack(void) > c.reserved_segments); > > /* main segments - reserved segments - (node + data segments) */ > - if (c.feature & F2FS_FEATURE_RO) { > - set_cp(free_segment_count, f2fs_get_usable_segments(sb) - 2); > - set_cp(user_block_count, ((get_cp(free_segment_count) + 2 - > - get_cp(overprov_segment_count)) * c.blks_per_seg)); > - } else { > - set_cp(free_segment_count, f2fs_get_usable_segments(sb) - 6); > - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - > - get_cp(overprov_segment_count)) * c.blks_per_seg)); > - } > + if (c.feature & F2FS_FEATURE_RO) > + used_segments += 2; > + else > + used_segments += 6; > + > + set_cp(user_block_count, (f2fs_get_usable_segments(sb) - > + get_cp(overprov_segment_count)) * c.blks_per_seg); > + set_cp(free_segment_count, f2fs_get_usable_segments(sb) - > + used_segments); > + > /* cp page (2), data summaries (1), node summaries (3) */ > set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); > flags = CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG; > @@ -825,8 +901,10 @@ static int f2fs_write_check_point_pack(void) > > set_cp(ckpt_flags, flags); > set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); > - set_cp(valid_node_count, c.curseg_offset[CURSEG_HOT_NODE]); > - set_cp(valid_inode_count, c.curseg_offset[CURSEG_HOT_NODE]); > + set_cp(valid_node_count, c.curseg_offset[CURSEG_HOT_NODE] + > + c.curseg_offset[CURSEG_COLD_NODE]); > + set_cp(valid_inode_count, c.curseg_offset[CURSEG_HOT_NODE] + > + c.curseg_offset[CURSEG_COLD_NODE]); > set_cp(next_free_nid, c.next_free_nid); > set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << > get_sb(log_blocks_per_seg)) / 8); > @@ -974,9 +1052,12 @@ static int f2fs_write_check_point_pack(void) > goto free_cp_payload; > } > > - /* Fill segment summary for COLD_NODE to zero. */ > + /* Prepare and write Segment summary for COLD_NODE */ > memset(sum, 0, F2FS_BLKSIZE); > SET_SUM_TYPE(sum, SUM_TYPE_NODE); > + memcpy(sum->entries, c.sum[CURSEG_COLD_NODE], > + sizeof(struct f2fs_summary) * MAX_CACHE_SUMS); > + > cp_seg_blk++; > DBG(1, "\tWriting Segment summary for COLD_NODE, at offset 0x%08"PRIx64"\n", > cp_seg_blk); > @@ -1209,10 +1290,40 @@ void update_summary_entry(int curseg_type, nid_t nid, > sum->ofs_in_node = cpu_to_le16(ofs_in_node); > } > > +static void add_dentry(struct f2fs_dentry_block *dent_blk, unsigned int *didx, > + const char *name, uint32_t ino, u8 type) > +{ > + int len = strlen(name); > + f2fs_hash_t hash; > + > + if (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) > + hash = 0; > + else > + hash = f2fs_dentry_hash(0, 0, (unsigned char *)name, len); > + > + F2FS_DENTRY_BLOCK_DENTRY(dent_blk, *didx).hash_code = cpu_to_le32(hash); > + F2FS_DENTRY_BLOCK_DENTRY(dent_blk, *didx).ino = cpu_to_le32(ino); > + F2FS_DENTRY_BLOCK_DENTRY(dent_blk, *didx).name_len = cpu_to_le16(len); > + F2FS_DENTRY_BLOCK_DENTRY(dent_blk, *didx).file_type = type; > + > + while (len > F2FS_SLOT_LEN) { > + memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, *didx), name, > + F2FS_SLOT_LEN); > + test_and_set_bit_le(*didx, dent_blk->dentry_bitmap); > + len -= (int)F2FS_SLOT_LEN; > + name += F2FS_SLOT_LEN; > + (*didx)++; > + } > + memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, *didx), name, len); > + test_and_set_bit_le(*didx, dent_blk->dentry_bitmap); > + (*didx)++; > +} > + > static block_t f2fs_add_default_dentry_root(void) > { > struct f2fs_dentry_block *dent_blk = NULL; > block_t data_blkaddr; > + unsigned int didx = 0; > > dent_blk = calloc(F2FS_BLKSIZE, 1); > if(dent_blk == NULL) { > @@ -1220,37 +1331,26 @@ static block_t f2fs_add_default_dentry_root(void) > return 0; > } > > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).hash_code = 0; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).ino = sb->root_ino; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).name_len = cpu_to_le16(1); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).file_type = F2FS_FT_DIR; > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 0), ".", 1); > + add_dentry(dent_blk, &didx, ".", > + le32_to_cpu(sb->root_ino), F2FS_FT_DIR); > + add_dentry(dent_blk, &didx, "..", > + le32_to_cpu(sb->root_ino), F2FS_FT_DIR); > > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).hash_code = 0; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).ino = sb->root_ino; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).name_len = cpu_to_le16(2); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).file_type = F2FS_FT_DIR; > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 1), "..", 2); > - > - /* bitmap for . and .. */ > - test_and_set_bit_le(0, dent_blk->dentry_bitmap); > - test_and_set_bit_le(1, dent_blk->dentry_bitmap); > - > - if (c.lpf_ino) { > - int len = strlen(LPF); > - f2fs_hash_t hash = f2fs_dentry_hash(0, 0, (unsigned char *)LPF, len); > + if (c.lpf_ino) > + add_dentry(dent_blk, &didx, LPF, c.lpf_ino, F2FS_FT_DIR); > > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 2).hash_code = cpu_to_le32(hash); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 2).ino = cpu_to_le32(c.lpf_ino); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 2).name_len = cpu_to_le16(len); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 2).file_type = F2FS_FT_DIR; > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 2), LPF, F2FS_SLOT_LEN); > + if (c.aliased_devices) { > + int i, dev_off = 0; > > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 3), &LPF[F2FS_SLOT_LEN], > - len - F2FS_SLOT_LEN); > + for (i = 1; i < c.ndevs; i++) { > + if (!device_is_aliased(i)) > + continue; > > - test_and_set_bit_le(2, dent_blk->dentry_bitmap); > - test_and_set_bit_le(3, dent_blk->dentry_bitmap); > + add_dentry(dent_blk, &didx, c.devices[i].alias_filename, > + c.first_alias_ino + dev_off, > + F2FS_FT_REG_FILE); > + dev_off++; > + } > } > > data_blkaddr = alloc_next_free_block(CURSEG_HOT_DATA); > @@ -1323,6 +1423,7 @@ static int f2fs_write_default_quota(int qtype, __le32 raw_id) > struct v2_disk_dqinfo ddqinfo; > struct v2r1_disk_dqblk dqblk; > block_t blkaddr; > + uint64_t icnt = 1, bcnt = 1; > int i; > > if (filebuf == NULL) { > @@ -1358,16 +1459,18 @@ static int f2fs_write_default_quota(int qtype, __le32 raw_id) > dqblk.dqb_pad = cpu_to_le32(0); > dqblk.dqb_ihardlimit = cpu_to_le64(0); > dqblk.dqb_isoftlimit = cpu_to_le64(0); > - if (c.lpf_ino) > - dqblk.dqb_curinodes = cpu_to_le64(2); > - else > - dqblk.dqb_curinodes = cpu_to_le64(1); > + if (c.lpf_ino) { > + icnt++; > + bcnt++; > + } > + if (c.aliased_devices) { > + icnt += c.aliased_devices; > + bcnt += c.aliased_segments * c.blks_per_seg; > + } > + dqblk.dqb_curinodes = cpu_to_le64(icnt); > dqblk.dqb_bhardlimit = cpu_to_le64(0); > dqblk.dqb_bsoftlimit = cpu_to_le64(0); > - if (c.lpf_ino) > - dqblk.dqb_curspace = cpu_to_le64(F2FS_BLKSIZE * 2); > - else > - dqblk.dqb_curspace = cpu_to_le64(F2FS_BLKSIZE); > + dqblk.dqb_curspace = cpu_to_le64(F2FS_BLKSIZE * bcnt); > dqblk.dqb_btime = cpu_to_le64(0); > dqblk.dqb_itime = cpu_to_le64(0); > > @@ -1490,6 +1593,7 @@ static block_t f2fs_add_default_dentry_lpf(void) > { > struct f2fs_dentry_block *dent_blk; > block_t data_blkaddr; > + unsigned int didx = 0; > > dent_blk = calloc(F2FS_BLKSIZE, 1); > if (dent_blk == NULL) { > @@ -1497,20 +1601,8 @@ static block_t f2fs_add_default_dentry_lpf(void) > return 0; > } > > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).hash_code = 0; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).ino = cpu_to_le32(c.lpf_ino); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).name_len = cpu_to_le16(1); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).file_type = F2FS_FT_DIR; > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 0), ".", 1); > - > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).hash_code = 0; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).ino = sb->root_ino; > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).name_len = cpu_to_le16(2); > - F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).file_type = F2FS_FT_DIR; > - memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 1), "..", 2); > - > - test_and_set_bit_le(0, dent_blk->dentry_bitmap); > - test_and_set_bit_le(1, dent_blk->dentry_bitmap); > + add_dentry(dent_blk, &didx, ".", c.lpf_ino, F2FS_FT_DIR); > + add_dentry(dent_blk, &didx, "..", c.lpf_ino, F2FS_FT_DIR); > > data_blkaddr = alloc_next_free_block(CURSEG_HOT_DATA); > > @@ -1578,6 +1670,104 @@ exit: > return err; > } > > +static void allocate_blocks_for_aliased_device(struct f2fs_node *raw_node, > + unsigned int dev_num) > +{ > + uint32_t start_segno = (c.devices[dev_num].start_blkaddr - > + get_sb(main_blkaddr)) / c.blks_per_seg; > + uint32_t end_segno = (c.devices[dev_num].end_blkaddr - > + get_sb(main_blkaddr) + 1) / c.blks_per_seg; > + uint32_t segno; > + uint64_t blkcnt; > + struct f2fs_sit_block *sit_blk = calloc(F2FS_BLKSIZE, 1); > + > + ASSERT(sit_blk); > + > + for (segno = start_segno; segno < end_segno; segno++) { > + struct f2fs_sit_entry *sit; > + uint64_t sit_blk_addr = get_sb(sit_blkaddr) + > + (segno / SIT_ENTRY_PER_BLOCK); > + > + ASSERT(dev_read_block(sit_blk, sit_blk_addr) >= 0); > + sit = &sit_blk->entries[segno % SIT_ENTRY_PER_BLOCK]; > + memset(&sit->valid_map, 0xFF, SIT_VBLOCK_MAP_SIZE); > + sit->vblocks = cpu_to_le16((CURSEG_COLD_DATA << > + SIT_VBLOCKS_SHIFT) | c.blks_per_seg); > + sit->mtime = cpu_to_le64(mkfs_time); > + ASSERT(dev_write_block(sit_blk, sit_blk_addr) >= 0); > + } > + > + blkcnt = (end_segno - start_segno) * c.blks_per_seg; > + raw_node->i.i_size = cpu_to_le64(blkcnt << get_sb(log_blocksize)); > + raw_node->i.i_blocks = cpu_to_le64(blkcnt + 1); > + > + raw_node->i.i_ext.fofs = cpu_to_le32(0); > + raw_node->i.i_ext.blk_addr = > + cpu_to_le32(c.devices[dev_num].start_blkaddr); > + raw_node->i.i_ext.len = cpu_to_le32(blkcnt); > + > + free(sit_blk); > +} > + > +static int f2fs_write_alias_inodes(void) > +{ > + struct f2fs_node *raw_node; > + block_t node_blkaddr; > + int err = 0; > + unsigned int i, dev_off = 0; > + > + ASSERT(c.aliased_devices); > + > + raw_node = calloc(F2FS_BLKSIZE, 1); > + if (raw_node == NULL) { > + MSG(1, "\tError: Calloc Failed for raw_node!!!\n"); > + return -1; > + } > + > + for (i = 1; i < c.ndevs; i++) { > + const char *filename; > + nid_t ino; > + > + if (!device_is_aliased(i)) > + continue; > + > + ino = c.first_alias_ino + dev_off; > + dev_off++; > + f2fs_init_inode(sb, raw_node, ino, mkfs_time, 0x81c0); > + > + raw_node->i.i_flags = cpu_to_le32(F2FS_IMMUTABLE_FL | > + F2FS_DEVICE_ALIAS_FL); > + raw_node->i.i_inline = F2FS_PIN_FILE; > + raw_node->i.i_pino = sb->root_ino; > + filename = c.devices[i].alias_filename; > + raw_node->i.i_namelen = cpu_to_le32(strlen(filename)); > + memcpy(raw_node->i.i_name, filename, strlen(filename)); > + > + node_blkaddr = alloc_next_free_block(CURSEG_COLD_NODE); > + F2FS_NODE_FOOTER(raw_node)->next_blkaddr = > + cpu_to_le32(node_blkaddr + 1); > + > + allocate_blocks_for_aliased_device(raw_node, i); > + > + DBG(1, "\tWriting aliased device inode (cold node), " > + "offset 0x%x\n", node_blkaddr); > + if (write_inode(raw_node, node_blkaddr) < 0) { > + MSG(1, "\tError: While writing the raw_node to " > + "disk!!!\n"); > + err = -1; > + goto exit; > + } > + > + update_nat_journal(ino, node_blkaddr); > + update_sit_journal(CURSEG_COLD_NODE); > + update_summary_entry(CURSEG_COLD_NODE, ino, 0); > + } > + > +exit: > + free(raw_node); > + return err; > +} > + > static int f2fs_create_root_dir(void) > { > enum quota_type qtype; > @@ -1607,6 +1797,15 @@ static int f2fs_create_root_dir(void) > } > } > > + if (c.aliased_devices) { > + err = f2fs_write_alias_inodes(); > + if (err < 0) { > + MSG(1, "\tError: Failed to write aliased device " > + "inodes!!!\n"); > + goto exit; > + } > + } > + > #ifndef WITH_ANDROID > err = f2fs_discard_obsolete_dnode(); > if (err < 0) { > diff --git a/mkfs/f2fs_format_main.c b/mkfs/f2fs_format_main.c > index 2ba1c21..b113bbc 100644 > --- a/mkfs/f2fs_format_main.c > +++ b/mkfs/f2fs_format_main.c > @@ -50,7 +50,7 @@ static void mkfs_usage() > MSG(0, "\nUsage: mkfs.f2fs [options] device [sectors]\n"); > MSG(0, "[options]:\n"); > MSG(0, " -b filesystem block size [default:4096]\n"); > - MSG(0, " -c [device_name] up to 7 additional devices, except meta device\n"); > + MSG(0, " -c [device_name[@alias_filename]] up to 7 additional devices, except meta device\n"); > MSG(0, " -d debug level [default:0]\n"); > MSG(0, " -e [cold file ext list] e.g. \"mp3,gif,mov\"\n"); > MSG(0, " -E [hot file ext list] e.g. \"db\"\n"); > @@ -105,6 +105,9 @@ static void f2fs_show_info() > > if (c.feature & F2FS_FEATURE_COMPRESSION) > MSG(0, "Info: Enable Compression\n"); > + > + if (c.feature & F2FS_FEATURE_DEVICE_ALIAS) > + MSG(0, "Info: Enable device aliasing\n"); > } > > #if defined(ANDROID_TARGET) && defined(HAVE_SYS_UTSNAME_H) > @@ -181,6 +184,7 @@ static void f2fs_parse_options(int argc, char *argv[]) > int32_t option=0; > int val; > char *token; > + int dev_num; > > while ((option = getopt_long(argc,argv,option_string,long_opts,NULL)) != EOF) { > switch (option) { > @@ -200,17 +204,35 @@ static void f2fs_parse_options(int argc, char *argv[]) > } > break; > case 'c': > - if (c.ndevs >= MAX_DEVICES) { > + dev_num = c.ndevs; > + > + if (dev_num >= MAX_DEVICES) { > MSG(0, "Error: Too many devices\n"); > mkfs_usage(); > } > > - if (strlen(optarg) > MAX_PATH_LEN) { > + token = strtok(optarg, "@"); > + if (strlen(token) > MAX_PATH_LEN) { > MSG(0, "Error: device path should be less than " > "%d characters\n", MAX_PATH_LEN); > mkfs_usage(); > } > - c.devices[c.ndevs++].path = strdup(optarg); > + c.devices[dev_num].path = strdup(token); > + token = strtok(NULL, ""); > + if (token) { > + if (strlen(token) > MAX_PATH_LEN) { > + MSG(0, "Error: alias_filename should " > + "be less than %d characters\n", > + MAX_PATH_LEN); > + mkfs_usage(); > + } > + c.devices[dev_num].alias_filename = > + strdup(token); > + if (!c.aliased_devices) > + c.feature |= F2FS_FEATURE_DEVICE_ALIAS; > + c.aliased_devices++; > + } > + c.ndevs++; > break; > case 'd': > c.dbg_lv = atoi(optarg); > -- > 2.46.0.662.g92d0881bb0-goog >