~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,20 +1,8 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* This file is part of UBIFS.
3	4	*
4	5	* Copyright (C) 2006-2008 Nokia Corporation.
5		- *
6		- * This program is free software; you can redistribute it and/or modify it
7		- * under the terms of the GNU General Public License version 2 as published by
8		- * the Free Software Foundation.
9		- *
10		- * This program is distributed in the hope that it will be useful, but WITHOUT
11		- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12		- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13		- * more details.
14		- *
15		- * You should have received a copy of the GNU General Public License along with
16		- * this program; if not, write to the Free Software Foundation, Inc., 51
17		- * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18	6	*
19	7	* Authors: Artem Bityutskiy (Битюцкий Артём)
20	8	* Adrian Hunter
..	..	@@ -88,6 +76,12 @@
88	76	static inline void zero_trun_node_unused(struct ubifs_trun_node *trun)
89	77	{
90	78	memset(trun->padding, 0, 12);
	79	+}
	80	+
	81	+static void ubifs_add_auth_dirt(struct ubifs_info *c, int lnum)
	82	+{
	83	+ if (ubifs_authenticated(c))
	84	+ ubifs_add_dirt(c, lnum, ubifs_auth_node_sz(c));
91	85	}
92	86
93	87	/**
..	..	@@ -228,34 +222,33 @@
228	222	return err;
229	223	}
230	224
231		-/**
232		- * write_node - write node to a journal head.
233		- * @c: UBIFS file-system description object
234		- * @jhead: journal head
235		- * @node: node to write
236		- * @len: node length
237		- * @lnum: LEB number written is returned here
238		- * @offs: offset written is returned here
239		- *
240		- * This function writes a node to reserved space of journal head @jhead.
241		- * Returns zero in case of success and a negative error code in case of
242		- * failure.
243		- */
244		-static int write_node(struct ubifs_info c, int jhead, void node, int len,
245		- int lnum, int offs)
	225	+static int ubifs_hash_nodes(struct ubifs_info c, void node,
	226	+ int len, struct shash_desc *hash)
246	227	{
247		- struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
	228	+ int auth_node_size = ubifs_auth_node_sz(c);
	229	+ int err;
248	230
249		- ubifs_assert(c, jhead != GCHD);
	231	+ while (1) {
	232	+ const struct ubifs_ch *ch = node;
	233	+ int nodelen = le32_to_cpu(ch->len);
250	234
251		- *lnum = c->jheads[jhead].wbuf.lnum;
252		- *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
	235	+ ubifs_assert(c, len >= auth_node_size);
253	236
254		- dbg_jnl("jhead %s, LEB %d:%d, len %d",
255		- dbg_jhead(jhead), lnum, offs, len);
256		- ubifs_prepare_node(c, node, len, 0);
	237	+ if (len == auth_node_size)
	238	+ break;
257	239
258		- return ubifs_wbuf_write_nolock(wbuf, node, len);
	240	+ ubifs_assert(c, len > nodelen);
	241	+ ubifs_assert(c, ch->magic == cpu_to_le32(UBIFS_NODE_MAGIC));
	242	+
	243	+ err = ubifs_shash_update(c, hash, (void *)node, nodelen);
	244	+ if (err)
	245	+ return err;
	246	+
	247	+ node += ALIGN(nodelen, 8);
	248	+ len -= ALIGN(nodelen, 8);
	249	+ }
	250	+
	251	+ return ubifs_prepare_auth_node(c, node, hash);
259	252	}
260	253
261	254	/**
..	..	@@ -268,9 +261,9 @@
268	261	* @offs: offset written is returned here
269	262	* @sync: non-zero if the write-buffer has to by synchronized
270	263	*
271		- * This function is the same as 'write_node()' but it does not assume the
272		- * buffer it is writing is a node, so it does not prepare it (which means
273		- * initializing common header and calculating CRC).
	264	+ * This function writes data to the reserved space of journal head @jhead.
	265	+ * Returns zero in case of success and a negative error code in case of
	266	+ * failure.
274	267	*/
275	268	static int write_head(struct ubifs_info c, int jhead, void buf, int len,
276	269	int lnum, int offs, int sync)
..	..	@@ -284,6 +277,12 @@
284	277	*offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
285	278	dbg_jnl("jhead %s, LEB %d:%d, len %d",
286	279	dbg_jhead(jhead), lnum, offs, len);
	280	+
	281	+ if (ubifs_authenticated(c)) {
	282	+ err = ubifs_hash_nodes(c, buf, len, c->jheads[jhead].log_hash);
	283	+ if (err)
	284	+ return err;
	285	+ }
287	286
288	287	err = ubifs_wbuf_write_nolock(wbuf, buf, len);
289	288	if (err)
..	..	@@ -504,7 +503,7 @@
504	503	static void set_dent_cookie(struct ubifs_info c, struct ubifs_dent_node dent)
505	504	{
506	505	if (c->double_hash)
507		- dent->cookie = prandom_u32();
	506	+ dent->cookie = (__force __le32) prandom_u32();
508	507	else
509	508	dent->cookie = 0;
510	509	}
..	..	@@ -540,7 +539,7 @@
540	539	const struct fscrypt_name nm, const struct inode inode,
541	540	int deletion, int xent)
542	541	{
543		- int err, dlen, ilen, len, lnum, ino_offs, dent_offs;
	542	+ int err, dlen, ilen, len, lnum, ino_offs, dent_offs, orphan_added = 0;
544	543	int aligned_dlen, aligned_ilen, sync = IS_DIRSYNC(dir);
545	544	int last_reference = !!(deletion && inode->i_nlink == 0);
546	545	struct ubifs_inode *ui = ubifs_inode(inode);
..	..	@@ -548,6 +547,9 @@
548	547	struct ubifs_dent_node *dent;
549	548	struct ubifs_ino_node *ino;
550	549	union ubifs_key dent_key, ino_key;
	550	+ u8 hash_dent[UBIFS_HASH_ARR_SZ];
	551	+ u8 hash_ino[UBIFS_HASH_ARR_SZ];
	552	+ u8 hash_ino_host[UBIFS_HASH_ARR_SZ];
551	553
552	554	ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
553	555
..	..	@@ -570,7 +572,10 @@
570	572
571	573	len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
572	574	/* Make sure to also account for extended attributes */
573		- len += host_ui->data_len;
	575	+ if (ubifs_authenticated(c))
	576	+ len += ALIGN(host_ui->data_len, 8) + ubifs_auth_node_sz(c);
	577	+ else
	578	+ len += host_ui->data_len;
574	579
575	580	dent = kzalloc(len, GFP_NOFS);
576	581	if (!dent)
..	..	@@ -602,11 +607,21 @@
602	607
603	608	zero_dent_node_unused(dent);
604	609	ubifs_prep_grp_node(c, dent, dlen, 0);
	610	+ err = ubifs_node_calc_hash(c, dent, hash_dent);
	611	+ if (err)
	612	+ goto out_release;
605	613
606	614	ino = (void *)dent + aligned_dlen;
607	615	pack_inode(c, ino, inode, 0);
	616	+ err = ubifs_node_calc_hash(c, ino, hash_ino);
	617	+ if (err)
	618	+ goto out_release;
	619	+
608	620	ino = (void *)ino + aligned_ilen;
609	621	pack_inode(c, ino, dir, 1);
	622	+ err = ubifs_node_calc_hash(c, ino, hash_ino_host);
	623	+ if (err)
	624	+ goto out_release;
610	625
611	626	if (last_reference) {
612	627	err = ubifs_add_orphan(c, inode->i_ino);
..	..	@@ -615,6 +630,7 @@
615	630	goto out_finish;
616	631	}
617	632	ui->del_cmtno = c->cmt_no;
	633	+ orphan_added = 1;
618	634	}
619	635
620	636	err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
..	..	@@ -628,6 +644,7 @@
628	644	}
629	645	release_head(c, BASEHD);
630	646	kfree(dent);
	647	+ ubifs_add_auth_dirt(c, lnum);
631	648
632	649	if (deletion) {
633	650	if (fname_name(nm) == NULL)
..	..	@@ -638,7 +655,8 @@
638	655	goto out_ro;
639	656	err = ubifs_add_dirt(c, lnum, dlen);
640	657	} else
641		- err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen, nm);
	658	+ err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen,
	659	+ hash_dent, nm);
642	660	if (err)
643	661	goto out_ro;
644	662
..	..	@@ -650,14 +668,14 @@
650	668	*/
651	669	ino_key_init(c, &ino_key, inode->i_ino);
652	670	ino_offs = dent_offs + aligned_dlen;
653		- err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen);
	671	+ err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen, hash_ino);
654	672	if (err)
655	673	goto out_ro;
656	674
657	675	ino_key_init(c, &ino_key, dir->i_ino);
658	676	ino_offs += aligned_ilen;
659	677	err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs,
660		- UBIFS_INO_NODE_SZ + host_ui->data_len);
	678	+ UBIFS_INO_NODE_SZ + host_ui->data_len, hash_ino_host);
661	679	if (err)
662	680	goto out_ro;
663	681
..	..	@@ -685,7 +703,7 @@
685	703	kfree(dent);
686	704	out_ro:
687	705	ubifs_ro_mode(c, err);
688		- if (last_reference)
	706	+ if (orphan_added)
689	707	ubifs_delete_orphan(c, inode->i_ino);
690	708	finish_reservation(c);
691	709	return err;
..	..	@@ -706,10 +724,12 @@
706	724	const union ubifs_key key, const void buf, int len)
707	725	{
708	726	struct ubifs_data_node *data;
709		- int err, lnum, offs, compr_type, out_len, compr_len;
	727	+ int err, lnum, offs, compr_type, out_len, compr_len, auth_len;
710	728	int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;
	729	+ int write_len;
711	730	struct ubifs_inode *ui = ubifs_inode(inode);
712		- bool encrypted = ubifs_crypt_is_encrypted(inode);
	731	+ bool encrypted = IS_ENCRYPTED(inode);
	732	+ u8 hash[UBIFS_HASH_ARR_SZ];
713	733
714	734	dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",
715	735	(unsigned long)key_inum(c, key), key_block(c, key), len);
..	..	@@ -718,7 +738,9 @@
718	738	if (encrypted)
719	739	dlen += UBIFS_CIPHER_BLOCK_SIZE;
720	740
721		- data = kmalloc(dlen, GFP_NOFS \| __GFP_NOWARN);
	741	+ auth_len = ubifs_auth_node_sz(c);
	742	+
	743	+ data = kmalloc(dlen + auth_len, GFP_NOFS \| __GFP_NOWARN);
722	744	if (!data) {
723	745	/*
724	746	* Fall-back to the write reserve buffer. Note, we might be
..	..	@@ -757,20 +779,33 @@
757	779	}
758	780
759	781	dlen = UBIFS_DATA_NODE_SZ + out_len;
	782	+ if (ubifs_authenticated(c))
	783	+ write_len = ALIGN(dlen, 8) + auth_len;
	784	+ else
	785	+ write_len = dlen;
	786	+
760	787	data->compr_type = cpu_to_le16(compr_type);
761	788
762	789	/* Make reservation before allocating sequence numbers */
763		- err = make_reservation(c, DATAHD, dlen);
	790	+ err = make_reservation(c, DATAHD, write_len);
764	791	if (err)
765	792	goto out_free;
766	793
767		- err = write_node(c, DATAHD, data, dlen, &lnum, &offs);
	794	+ ubifs_prepare_node(c, data, dlen, 0);
	795	+ err = write_head(c, DATAHD, data, write_len, &lnum, &offs, 0);
768	796	if (err)
769	797	goto out_release;
	798	+
	799	+ err = ubifs_node_calc_hash(c, data, hash);
	800	+ if (err)
	801	+ goto out_release;
	802	+
770	803	ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
771	804	release_head(c, DATAHD);
772	805
773		- err = ubifs_tnc_add(c, key, lnum, offs, dlen);
	806	+ ubifs_add_auth_dirt(c, lnum);
	807	+
	808	+ err = ubifs_tnc_add(c, key, lnum, offs, dlen, hash);
774	809	if (err)
775	810	goto out_ro;
776	811
..	..	@@ -806,9 +841,12 @@
806	841	int ubifs_jnl_write_inode(struct ubifs_info c, const struct inode inode)
807	842	{
808	843	int err, lnum, offs;
809		- struct ubifs_ino_node *ino;
	844	+ struct ubifs_ino_node ino, ino_start;
810	845	struct ubifs_inode *ui = ubifs_inode(inode);
811		- int sync = 0, len = UBIFS_INO_NODE_SZ, last_reference = !inode->i_nlink;
	846	+ int sync = 0, write_len = 0, ilen = UBIFS_INO_NODE_SZ;
	847	+ int last_reference = !inode->i_nlink;
	848	+ int kill_xattrs = ui->xattr_cnt && last_reference;
	849	+ u8 hash[UBIFS_HASH_ARR_SZ];
812	850
813	851	dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
814	852
..	..	@@ -817,20 +855,83 @@
817	855	* need to synchronize the write-buffer either.
818	856	*/
819	857	if (!last_reference) {
820		- len += ui->data_len;
	858	+ ilen += ui->data_len;
821	859	sync = IS_SYNC(inode);
	860	+ } else if (kill_xattrs) {
	861	+ write_len += UBIFS_INO_NODE_SZ * ui->xattr_cnt;
822	862	}
823		- ino = kmalloc(len, GFP_NOFS);
	863	+
	864	+ if (ubifs_authenticated(c))
	865	+ write_len += ALIGN(ilen, 8) + ubifs_auth_node_sz(c);
	866	+ else
	867	+ write_len += ilen;
	868	+
	869	+ ino_start = ino = kmalloc(write_len, GFP_NOFS);
824	870	if (!ino)
825	871	return -ENOMEM;
826	872
827	873	/* Make reservation before allocating sequence numbers */
828		- err = make_reservation(c, BASEHD, len);
	874	+ err = make_reservation(c, BASEHD, write_len);
829	875	if (err)
830	876	goto out_free;
831	877
	878	+ if (kill_xattrs) {
	879	+ union ubifs_key key;
	880	+ struct fscrypt_name nm = {0};
	881	+ struct inode *xino;
	882	+ struct ubifs_dent_node xent, pxent = NULL;
	883	+
	884	+ if (ui->xattr_cnt > ubifs_xattr_max_cnt(c)) {
	885	+ err = -EPERM;
	886	+ ubifs_err(c, "Cannot delete inode, it has too much xattrs!");
	887	+ goto out_release;
	888	+ }
	889	+
	890	+ lowest_xent_key(c, &key, inode->i_ino);
	891	+ while (1) {
	892	+ xent = ubifs_tnc_next_ent(c, &key, &nm);
	893	+ if (IS_ERR(xent)) {
	894	+ err = PTR_ERR(xent);
	895	+ if (err == -ENOENT)
	896	+ break;
	897	+
	898	+ kfree(pxent);
	899	+ goto out_release;
	900	+ }
	901	+
	902	+ fname_name(&nm) = xent->name;
	903	+ fname_len(&nm) = le16_to_cpu(xent->nlen);
	904	+
	905	+ xino = ubifs_iget(c->vfs_sb, le64_to_cpu(xent->inum));
	906	+ if (IS_ERR(xino)) {
	907	+ err = PTR_ERR(xino);
	908	+ ubifs_err(c, "dead directory entry '%s', error %d",
	909	+ xent->name, err);
	910	+ ubifs_ro_mode(c, err);
	911	+ kfree(pxent);
	912	+ kfree(xent);
	913	+ goto out_release;
	914	+ }
	915	+ ubifs_assert(c, ubifs_inode(xino)->xattr);
	916	+
	917	+ clear_nlink(xino);
	918	+ pack_inode(c, ino, xino, 0);
	919	+ ino = (void *)ino + UBIFS_INO_NODE_SZ;
	920	+ iput(xino);
	921	+
	922	+ kfree(pxent);
	923	+ pxent = xent;
	924	+ key_read(c, &xent->key, &key);
	925	+ }
	926	+ kfree(pxent);
	927	+ }
	928	+
832	929	pack_inode(c, ino, inode, 1);
833		- err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
	930	+ err = ubifs_node_calc_hash(c, ino, hash);
	931	+ if (err)
	932	+ goto out_release;
	933	+
	934	+ err = write_head(c, BASEHD, ino_start, write_len, &lnum, &offs, sync);
834	935	if (err)
835	936	goto out_release;
836	937	if (!sync)
..	..	@@ -843,12 +944,14 @@
843	944	if (err)
844	945	goto out_ro;
845	946	ubifs_delete_orphan(c, inode->i_ino);
846		- err = ubifs_add_dirt(c, lnum, len);
	947	+ err = ubifs_add_dirt(c, lnum, write_len);
847	948	} else {
848	949	union ubifs_key key;
849	950
	951	+ ubifs_add_auth_dirt(c, lnum);
	952	+
850	953	ino_key_init(c, &key, inode->i_ino);
851		- err = ubifs_tnc_add(c, &key, lnum, offs, len);
	954	+ err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash);
852	955	}
853	956	if (err)
854	957	goto out_ro;
..	..	@@ -857,7 +960,7 @@
857	960	spin_lock(&ui->ui_lock);
858	961	ui->synced_i_size = ui->ui_size;
859	962	spin_unlock(&ui->ui_lock);
860		- kfree(ino);
	963	+ kfree(ino_start);
861	964	return 0;
862	965
863	966	out_release:
..	..	@@ -866,7 +969,7 @@
866	969	ubifs_ro_mode(c, err);
867	970	finish_reservation(c);
868	971	out_free:
869		- kfree(ino);
	972	+ kfree(ino_start);
870	973	return err;
871	974	}
872	975
..	..	@@ -906,8 +1009,8 @@
906	1009
907	1010	ubifs_assert(c, inode->i_nlink == 0);
908	1011
909		- if (ui->del_cmtno != c->cmt_no)
910		- /* A commit happened for sure */
	1012	+ if (ui->xattr_cnt \|\| ui->del_cmtno != c->cmt_no)
	1013	+ /* A commit happened for sure or inode hosts xattrs */
911	1014	return ubifs_jnl_write_inode(c, inode);
912	1015
913	1016	down_read(&c->commit_sem);
..	..	@@ -958,6 +1061,10 @@
958	1061	int aligned_dlen1, aligned_dlen2;
959	1062	int twoparents = (fst_dir != snd_dir);
960	1063	void *p;
	1064	+ u8 hash_dent1[UBIFS_HASH_ARR_SZ];
	1065	+ u8 hash_dent2[UBIFS_HASH_ARR_SZ];
	1066	+ u8 hash_p1[UBIFS_HASH_ARR_SZ];
	1067	+ u8 hash_p2[UBIFS_HASH_ARR_SZ];
961	1068
962	1069	ubifs_assert(c, ubifs_inode(fst_dir)->data_len == 0);
963	1070	ubifs_assert(c, ubifs_inode(snd_dir)->data_len == 0);
..	..	@@ -972,6 +1079,8 @@
972	1079	len = aligned_dlen1 + aligned_dlen2 + ALIGN(plen, 8);
973	1080	if (twoparents)
974	1081	len += plen;
	1082	+
	1083	+ len += ubifs_auth_node_sz(c);
975	1084
976	1085	dent1 = kzalloc(len, GFP_NOFS);
977	1086	if (!dent1)
..	..	@@ -993,6 +1102,9 @@
993	1102	set_dent_cookie(c, dent1);
994	1103	zero_dent_node_unused(dent1);
995	1104	ubifs_prep_grp_node(c, dent1, dlen1, 0);
	1105	+ err = ubifs_node_calc_hash(c, dent1, hash_dent1);
	1106	+ if (err)
	1107	+ goto out_release;
996	1108
997	1109	/* Make new dent for 2nd entry */
998	1110	dent2 = (void *)dent1 + aligned_dlen1;
..	..	@@ -1006,14 +1118,26 @@
1006	1118	set_dent_cookie(c, dent2);
1007	1119	zero_dent_node_unused(dent2);
1008	1120	ubifs_prep_grp_node(c, dent2, dlen2, 0);
	1121	+ err = ubifs_node_calc_hash(c, dent2, hash_dent2);
	1122	+ if (err)
	1123	+ goto out_release;
1009	1124
1010	1125	p = (void *)dent2 + aligned_dlen2;
1011		- if (!twoparents)
	1126	+ if (!twoparents) {
1012	1127	pack_inode(c, p, fst_dir, 1);
1013		- else {
	1128	+ err = ubifs_node_calc_hash(c, p, hash_p1);
	1129	+ if (err)
	1130	+ goto out_release;
	1131	+ } else {
1014	1132	pack_inode(c, p, fst_dir, 0);
	1133	+ err = ubifs_node_calc_hash(c, p, hash_p1);
	1134	+ if (err)
	1135	+ goto out_release;
1015	1136	p += ALIGN(plen, 8);
1016	1137	pack_inode(c, p, snd_dir, 1);
	1138	+ err = ubifs_node_calc_hash(c, p, hash_p2);
	1139	+ if (err)
	1140	+ goto out_release;
1017	1141	}
1018	1142
1019	1143	err = write_head(c, BASEHD, dent1, len, &lnum, &offs, sync);
..	..	@@ -1027,28 +1151,30 @@
1027	1151	}
1028	1152	release_head(c, BASEHD);
1029	1153
	1154	+ ubifs_add_auth_dirt(c, lnum);
	1155	+
1030	1156	dent_key_init(c, &key, snd_dir->i_ino, snd_nm);
1031		- err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, snd_nm);
	1157	+ err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, snd_nm);
1032	1158	if (err)
1033	1159	goto out_ro;
1034	1160
1035	1161	offs += aligned_dlen1;
1036	1162	dent_key_init(c, &key, fst_dir->i_ino, fst_nm);
1037		- err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, fst_nm);
	1163	+ err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, fst_nm);
1038	1164	if (err)
1039	1165	goto out_ro;
1040	1166
1041	1167	offs += aligned_dlen2;
1042	1168
1043	1169	ino_key_init(c, &key, fst_dir->i_ino);
1044		- err = ubifs_tnc_add(c, &key, lnum, offs, plen);
	1170	+ err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p1);
1045	1171	if (err)
1046	1172	goto out_ro;
1047	1173
1048	1174	if (twoparents) {
1049	1175	offs += ALIGN(plen, 8);
1050	1176	ino_key_init(c, &key, snd_dir->i_ino);
1051		- err = ubifs_tnc_add(c, &key, lnum, offs, plen);
	1177	+ err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p2);
1052	1178	if (err)
1053	1179	goto out_ro;
1054	1180	}
..	..	@@ -1096,11 +1222,16 @@
1096	1222	void *p;
1097	1223	union ubifs_key key;
1098	1224	struct ubifs_dent_node dent, dent2;
1099		- int err, dlen1, dlen2, ilen, lnum, offs, len;
	1225	+ int err, dlen1, dlen2, ilen, lnum, offs, len, orphan_added = 0;
1100	1226	int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
1101	1227	int last_reference = !!(new_inode && new_inode->i_nlink == 0);
1102	1228	int move = (old_dir != new_dir);
1103		- struct ubifs_inode *uninitialized_var(new_ui);
	1229	+ struct ubifs_inode *new_ui;
	1230	+ u8 hash_old_dir[UBIFS_HASH_ARR_SZ];
	1231	+ u8 hash_new_dir[UBIFS_HASH_ARR_SZ];
	1232	+ u8 hash_new_inode[UBIFS_HASH_ARR_SZ];
	1233	+ u8 hash_dent1[UBIFS_HASH_ARR_SZ];
	1234	+ u8 hash_dent2[UBIFS_HASH_ARR_SZ];
1104	1235
1105	1236	ubifs_assert(c, ubifs_inode(old_dir)->data_len == 0);
1106	1237	ubifs_assert(c, ubifs_inode(new_dir)->data_len == 0);
..	..	@@ -1123,6 +1254,9 @@
1123	1254	len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
1124	1255	if (move)
1125	1256	len += plen;
	1257	+
	1258	+ len += ubifs_auth_node_sz(c);
	1259	+
1126	1260	dent = kzalloc(len, GFP_NOFS);
1127	1261	if (!dent)
1128	1262	return -ENOMEM;
..	..	@@ -1143,6 +1277,9 @@
1143	1277	set_dent_cookie(c, dent);
1144	1278	zero_dent_node_unused(dent);
1145	1279	ubifs_prep_grp_node(c, dent, dlen1, 0);
	1280	+ err = ubifs_node_calc_hash(c, dent, hash_dent1);
	1281	+ if (err)
	1282	+ goto out_release;
1146	1283
1147	1284	dent2 = (void *)dent + aligned_dlen1;
1148	1285	dent2->ch.node_type = UBIFS_DENT_NODE;
..	..	@@ -1162,19 +1299,36 @@
1162	1299	set_dent_cookie(c, dent2);
1163	1300	zero_dent_node_unused(dent2);
1164	1301	ubifs_prep_grp_node(c, dent2, dlen2, 0);
	1302	+ err = ubifs_node_calc_hash(c, dent2, hash_dent2);
	1303	+ if (err)
	1304	+ goto out_release;
1165	1305
1166	1306	p = (void *)dent2 + aligned_dlen2;
1167	1307	if (new_inode) {
1168	1308	pack_inode(c, p, new_inode, 0);
	1309	+ err = ubifs_node_calc_hash(c, p, hash_new_inode);
	1310	+ if (err)
	1311	+ goto out_release;
	1312	+
1169	1313	p += ALIGN(ilen, 8);
1170	1314	}
1171	1315
1172		- if (!move)
	1316	+ if (!move) {
1173	1317	pack_inode(c, p, old_dir, 1);
1174		- else {
	1318	+ err = ubifs_node_calc_hash(c, p, hash_old_dir);
	1319	+ if (err)
	1320	+ goto out_release;
	1321	+ } else {
1175	1322	pack_inode(c, p, old_dir, 0);
	1323	+ err = ubifs_node_calc_hash(c, p, hash_old_dir);
	1324	+ if (err)
	1325	+ goto out_release;
	1326	+
1176	1327	p += ALIGN(plen, 8);
1177	1328	pack_inode(c, p, new_dir, 1);
	1329	+ err = ubifs_node_calc_hash(c, p, hash_new_dir);
	1330	+ if (err)
	1331	+ goto out_release;
1178	1332	}
1179	1333
1180	1334	if (last_reference) {
..	..	@@ -1184,6 +1338,7 @@
1184	1338	goto out_finish;
1185	1339	}
1186	1340	new_ui->del_cmtno = c->cmt_no;
	1341	+ orphan_added = 1;
1187	1342	}
1188	1343
1189	1344	err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
..	..	@@ -1200,15 +1355,17 @@
1200	1355	}
1201	1356	release_head(c, BASEHD);
1202	1357
	1358	+ ubifs_add_auth_dirt(c, lnum);
	1359	+
1203	1360	dent_key_init(c, &key, new_dir->i_ino, new_nm);
1204		- err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, new_nm);
	1361	+ err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, new_nm);
1205	1362	if (err)
1206	1363	goto out_ro;
1207	1364
1208	1365	offs += aligned_dlen1;
1209	1366	if (whiteout) {
1210	1367	dent_key_init(c, &key, old_dir->i_ino, old_nm);
1211		- err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, old_nm);
	1368	+ err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, old_nm);
1212	1369	if (err)
1213	1370	goto out_ro;
1214	1371
..	..	@@ -1227,21 +1384,21 @@
1227	1384	offs += aligned_dlen2;
1228	1385	if (new_inode) {
1229	1386	ino_key_init(c, &key, new_inode->i_ino);
1230		- err = ubifs_tnc_add(c, &key, lnum, offs, ilen);
	1387	+ err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash_new_inode);
1231	1388	if (err)
1232	1389	goto out_ro;
1233	1390	offs += ALIGN(ilen, 8);
1234	1391	}
1235	1392
1236	1393	ino_key_init(c, &key, old_dir->i_ino);
1237		- err = ubifs_tnc_add(c, &key, lnum, offs, plen);
	1394	+ err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_old_dir);
1238	1395	if (err)
1239	1396	goto out_ro;
1240	1397
1241	1398	if (move) {
1242	1399	offs += ALIGN(plen, 8);
1243	1400	ino_key_init(c, &key, new_dir->i_ino);
1244		- err = ubifs_tnc_add(c, &key, lnum, offs, plen);
	1401	+ err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_new_dir);
1245	1402	if (err)
1246	1403	goto out_ro;
1247	1404	}
..	..	@@ -1263,7 +1420,7 @@
1263	1420	release_head(c, BASEHD);
1264	1421	out_ro:
1265	1422	ubifs_ro_mode(c, err);
1266		- if (last_reference)
	1423	+ if (orphan_added)
1267	1424	ubifs_delete_orphan(c, new_inode->i_ino);
1268	1425	out_finish:
1269	1426	finish_reservation(c);
..	..	@@ -1298,7 +1455,7 @@
1298	1455	dlen = old_dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1299	1456	compr_type = le16_to_cpu(dn->compr_type);
1300	1457
1301		- if (ubifs_crypt_is_encrypted(inode)) {
	1458	+ if (IS_ENCRYPTED(inode)) {
1302	1459	err = ubifs_decrypt(inode, dn, &dlen, block);
1303	1460	if (err)
1304	1461	goto out;
..	..	@@ -1314,7 +1471,7 @@
1314	1471	ubifs_compress(c, buf, *new_len, &dn->data, &out_len, &compr_type);
1315	1472	}
1316	1473
1317		- if (ubifs_crypt_is_encrypted(inode)) {
	1474	+ if (IS_ENCRYPTED(inode)) {
1318	1475	err = ubifs_encrypt(inode, dn, out_len, &old_dlen, block);
1319	1476	if (err)
1320	1477	goto out;
..	..	@@ -1355,11 +1512,13 @@
1355	1512	union ubifs_key key, to_key;
1356	1513	struct ubifs_ino_node *ino;
1357	1514	struct ubifs_trun_node *trun;
1358		- struct ubifs_data_node *uninitialized_var(dn);
	1515	+ struct ubifs_data_node *dn;
1359	1516	int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1360	1517	struct ubifs_inode *ui = ubifs_inode(inode);
1361	1518	ino_t inum = inode->i_ino;
1362	1519	unsigned int blk;
	1520	+ u8 hash_ino[UBIFS_HASH_ARR_SZ];
	1521	+ u8 hash_dn[UBIFS_HASH_ARR_SZ];
1363	1522
1364	1523	dbg_jnl("ino %lu, size %lld -> %lld",
1365	1524	(unsigned long)inum, old_size, new_size);
..	..	@@ -1369,6 +1528,9 @@
1369	1528
1370	1529	sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1371	1530	UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
	1531	+
	1532	+ sz += ubifs_auth_node_sz(c);
	1533	+
1372	1534	ino = kmalloc(sz, GFP_NOFS);
1373	1535	if (!ino)
1374	1536	return -ENOMEM;
..	..	@@ -1414,16 +1576,28 @@
1414	1576
1415	1577	/* Must make reservation before allocating sequence numbers */
1416	1578	len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1417		- if (dlen)
	1579	+
	1580	+ if (ubifs_authenticated(c))
	1581	+ len += ALIGN(dlen, 8) + ubifs_auth_node_sz(c);
	1582	+ else
1418	1583	len += dlen;
	1584	+
1419	1585	err = make_reservation(c, BASEHD, len);
1420	1586	if (err)
1421	1587	goto out_free;
1422	1588
1423	1589	pack_inode(c, ino, inode, 0);
	1590	+ err = ubifs_node_calc_hash(c, ino, hash_ino);
	1591	+ if (err)
	1592	+ goto out_release;
	1593	+
1424	1594	ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1425		- if (dlen)
	1595	+ if (dlen) {
1426	1596	ubifs_prep_grp_node(c, dn, dlen, 1);
	1597	+ err = ubifs_node_calc_hash(c, dn, hash_dn);
	1598	+ if (err)
	1599	+ goto out_release;
	1600	+ }
1427	1601
1428	1602	err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1429	1603	if (err)
..	..	@@ -1432,15 +1606,17 @@
1432	1606	ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1433	1607	release_head(c, BASEHD);
1434	1608
	1609	+ ubifs_add_auth_dirt(c, lnum);
	1610	+
1435	1611	if (dlen) {
1436	1612	sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1437		- err = ubifs_tnc_add(c, &key, lnum, sz, dlen);
	1613	+ err = ubifs_tnc_add(c, &key, lnum, sz, dlen, hash_dn);
1438	1614	if (err)
1439	1615	goto out_ro;
1440	1616	}
1441	1617
1442	1618	ino_key_init(c, &key, inum);
1443		- err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ);
	1619	+ err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ, hash_ino);
1444	1620	if (err)
1445	1621	goto out_ro;
1446	1622
..	..	@@ -1495,12 +1671,13 @@
1495	1671	const struct inode *inode,
1496	1672	const struct fscrypt_name *nm)
1497	1673	{
1498		- int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen;
	1674	+ int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen, write_len;
1499	1675	struct ubifs_dent_node *xent;
1500	1676	struct ubifs_ino_node *ino;
1501	1677	union ubifs_key xent_key, key1, key2;
1502	1678	int sync = IS_DIRSYNC(host);
1503	1679	struct ubifs_inode *host_ui = ubifs_inode(host);
	1680	+ u8 hash[UBIFS_HASH_ARR_SZ];
1504	1681
1505	1682	ubifs_assert(c, inode->i_nlink == 0);
1506	1683	ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
..	..	@@ -1514,12 +1691,14 @@
1514	1691	hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1515	1692	len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1516	1693
1517		- xent = kzalloc(len, GFP_NOFS);
	1694	+ write_len = len + ubifs_auth_node_sz(c);
	1695	+
	1696	+ xent = kzalloc(write_len, GFP_NOFS);
1518	1697	if (!xent)
1519	1698	return -ENOMEM;
1520	1699
1521	1700	/* Make reservation before allocating sequence numbers */
1522		- err = make_reservation(c, BASEHD, len);
	1701	+ err = make_reservation(c, BASEHD, write_len);
1523	1702	if (err) {
1524	1703	kfree(xent);
1525	1704	return err;
..	..	@@ -1540,11 +1719,16 @@
1540	1719	pack_inode(c, ino, inode, 0);
1541	1720	ino = (void *)ino + UBIFS_INO_NODE_SZ;
1542	1721	pack_inode(c, ino, host, 1);
	1722	+ err = ubifs_node_calc_hash(c, ino, hash);
	1723	+ if (err)
	1724	+ goto out_release;
1543	1725
1544		- err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
	1726	+ err = write_head(c, BASEHD, xent, write_len, &lnum, &xent_offs, sync);
1545	1727	if (!sync && !err)
1546	1728	ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1547	1729	release_head(c, BASEHD);
	1730	+
	1731	+ ubifs_add_auth_dirt(c, lnum);
1548	1732	kfree(xent);
1549	1733	if (err)
1550	1734	goto out_ro;
..	..	@@ -1572,7 +1756,7 @@
1572	1756
1573	1757	/* And update TNC with the new host inode position */
1574	1758	ino_key_init(c, &key1, host->i_ino);
1575		- err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen);
	1759	+ err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen, hash);
1576	1760	if (err)
1577	1761	goto out_ro;
1578	1762
..	..	@@ -1583,6 +1767,9 @@
1583	1767	mark_inode_clean(c, host_ui);
1584	1768	return 0;
1585	1769
	1770	+out_release:
	1771	+ kfree(xent);
	1772	+ release_head(c, BASEHD);
1586	1773	out_ro:
1587	1774	ubifs_ro_mode(c, err);
1588	1775	finish_reservation(c);
..	..	@@ -1610,9 +1797,10 @@
1610	1797	struct ubifs_ino_node *ino;
1611	1798	union ubifs_key key;
1612	1799	int sync = IS_DIRSYNC(host);
	1800	+ u8 hash_host[UBIFS_HASH_ARR_SZ];
	1801	+ u8 hash[UBIFS_HASH_ARR_SZ];
1613	1802
1614	1803	dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1615		- ubifs_assert(c, host->i_nlink > 0);
1616	1804	ubifs_assert(c, inode->i_nlink > 0);
1617	1805	ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1618	1806
..	..	@@ -1620,6 +1808,8 @@
1620	1808	len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1621	1809	aligned_len1 = ALIGN(len1, 8);
1622	1810	aligned_len = aligned_len1 + ALIGN(len2, 8);
	1811	+
	1812	+ aligned_len += ubifs_auth_node_sz(c);
1623	1813
1624	1814	ino = kzalloc(aligned_len, GFP_NOFS);
1625	1815	if (!ino)
..	..	@@ -1631,7 +1821,13 @@
1631	1821	goto out_free;
1632	1822
1633	1823	pack_inode(c, ino, host, 0);
	1824	+ err = ubifs_node_calc_hash(c, ino, hash_host);
	1825	+ if (err)
	1826	+ goto out_release;
1634	1827	pack_inode(c, (void *)ino + aligned_len1, inode, 1);
	1828	+ err = ubifs_node_calc_hash(c, (void *)ino + aligned_len1, hash);
	1829	+ if (err)
	1830	+ goto out_release;
1635	1831
1636	1832	err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1637	1833	if (!sync && !err) {
..	..	@@ -1644,13 +1840,15 @@
1644	1840	if (err)
1645	1841	goto out_ro;
1646	1842
	1843	+ ubifs_add_auth_dirt(c, lnum);
	1844	+
1647	1845	ino_key_init(c, &key, host->i_ino);
1648		- err = ubifs_tnc_add(c, &key, lnum, offs, len1);
	1846	+ err = ubifs_tnc_add(c, &key, lnum, offs, len1, hash_host);
1649	1847	if (err)
1650	1848	goto out_ro;
1651	1849
1652	1850	ino_key_init(c, &key, inode->i_ino);
1653		- err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2);
	1851	+ err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2, hash);
1654	1852	if (err)
1655	1853	goto out_ro;
1656	1854
..	..	@@ -1662,6 +1860,8 @@
1662	1860	kfree(ino);
1663	1861	return 0;
1664	1862
	1863	+out_release:
	1864	+ release_head(c, BASEHD);
1665	1865	out_ro:
1666	1866	ubifs_ro_mode(c, err);
1667	1867	finish_reservation(c);