~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,10 +1,7 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	4	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4		- *
5		- * This copyrighted material is made available to anyone wishing to use,
6		- * modify, copy, or redistribute it subject to the terms and conditions
7		- * of the GNU General Public License version 2.
8	5	*/
9	6
10	7	#include <linux/spinlock.h>
..	..	@@ -14,6 +11,7 @@
14	11	#include <linux/gfs2_ondisk.h>
15	12	#include <linux/crc32.h>
16	13	#include <linux/iomap.h>
	14	+#include <linux/ktime.h>
17	15
18	16	#include "gfs2.h"
19	17	#include "incore.h"
..	..	@@ -58,7 +56,6 @@
58	56	u64 block, struct page *page)
59	57	{
60	58	struct inode *inode = &ip->i_inode;
61		- struct buffer_head *bh;
62	59	int release = 0;
63	60
64	61	if (!page \|\| page->index) {
..	..	@@ -82,20 +79,21 @@
82	79	SetPageUptodate(page);
83	80	}
84	81
85		- if (!page_has_buffers(page))
86		- create_empty_buffers(page, BIT(inode->i_blkbits),
87		- BIT(BH_Uptodate));
	82	+ if (gfs2_is_jdata(ip)) {
	83	+ struct buffer_head *bh;
88	84
89		- bh = page_buffers(page);
	85	+ if (!page_has_buffers(page))
	86	+ create_empty_buffers(page, BIT(inode->i_blkbits),
	87	+ BIT(BH_Uptodate));
90	88
91		- if (!buffer_mapped(bh))
92		- map_bh(bh, inode->i_sb, block);
	89	+ bh = page_buffers(page);
	90	+ if (!buffer_mapped(bh))
	91	+ map_bh(bh, inode->i_sb, block);
93	92
94		- set_buffer_uptodate(bh);
95		- if (gfs2_is_jdata(ip))
	93	+ set_buffer_uptodate(bh);
96	94	gfs2_trans_add_data(ip->i_gl, bh);
97		- else {
98		- mark_buffer_dirty(bh);
	95	+ } else {
	96	+ set_page_dirty(page);
99	97	gfs2_ordered_add_inode(ip);
100	98	}
101	99
..	..	@@ -141,7 +139,7 @@
141	139	if (error)
142	140	goto out_brelse;
143	141	if (isdir) {
144		- gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
	142	+ gfs2_trans_remove_revoke(GFS2_SB(&ip->i_inode), block, 1);
145	143	error = gfs2_dir_get_new_buffer(ip, block, &bh);
146	144	if (error)
147	145	goto out_brelse;
..	..	@@ -637,7 +635,6 @@
637	635	* gfs2_iomap_alloc - Build a metadata tree of the requested height
638	636	* @inode: The GFS2 inode
639	637	* @iomap: The iomap structure
640		- * @flags: iomap flags
641	638	* @mp: The metapath, with proper height information calculated
642	639	*
643	640	* In this routine we may have to alloc:
..	..	@@ -664,7 +661,7 @@
664	661	*/
665	662
666	663	static int gfs2_iomap_alloc(struct inode inode, struct iomap iomap,
667		- unsigned flags, struct metapath *mp)
	664	+ struct metapath *mp)
668	665	{
669	666	struct gfs2_inode *ip = GFS2_I(inode);
670	667	struct gfs2_sbd *sdp = GFS2_SB(inode);
..	..	@@ -715,7 +712,7 @@
715	712	goto out;
716	713	alloced += n;
717	714	if (state != ALLOC_DATA \|\| gfs2_is_jdata(ip))
718		- gfs2_trans_add_unrevoke(sdp, bn, n);
	715	+ gfs2_trans_remove_revoke(sdp, bn, n);
719	716	switch (state) {
720	717	/* Growing height of tree */
721	718	case ALLOC_GROW_HEIGHT:
..	..	@@ -749,7 +746,7 @@
749	746	}
750	747	if (n == 0)
751	748	break;
752		- /* Branching from existing tree */
	749	+ fallthrough; /* To branching from existing tree */
753	750	case ALLOC_GROW_DEPTH:
754	751	if (i > 1 && i < mp->mp_fheight)
755	752	gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
..	..	@@ -760,7 +757,7 @@
760	757	state = ALLOC_DATA;
761	758	if (n == 0)
762	759	break;
763		- /* Tree complete, adding data blocks */
	760	+ fallthrough; /* To tree complete, adding data blocks */
764	761	case ALLOC_DATA:
765	762	BUG_ON(n > dblks);
766	763	BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
..	..	@@ -964,6 +961,32 @@
964	961	goto out;
965	962	}
966	963
	964	+/**
	965	+ * gfs2_lblk_to_dblk - convert logical block to disk block
	966	+ * @inode: the inode of the file we're mapping
	967	+ * @lblock: the block relative to the start of the file
	968	+ * @dblock: the returned dblock, if no error
	969	+ *
	970	+ * This function maps a single block from a file logical block (relative to
	971	+ * the start of the file) to a file system absolute block using iomap.
	972	+ *
	973	+ * Returns: the absolute file system block, or an error
	974	+ */
	975	+int gfs2_lblk_to_dblk(struct inode inode, u32 lblock, u64 dblock)
	976	+{
	977	+ struct iomap iomap = { };
	978	+ struct metapath mp = { .mp_aheight = 1, };
	979	+ loff_t pos = (loff_t)lblock << inode->i_blkbits;
	980	+ int ret;
	981	+
	982	+ ret = gfs2_iomap_get(inode, pos, i_blocksize(inode), 0, &iomap, &mp);
	983	+ release_metapath(&mp);
	984	+ if (ret == 0)
	985	+ *dblock = iomap.addr >> inode->i_blkbits;
	986	+
	987	+ return ret;
	988	+}
	989	+
967	990	static int gfs2_write_lock(struct inode *inode)
968	991	{
969	992	struct gfs2_inode *ip = GFS2_I(inode);
..	..	@@ -1004,14 +1027,38 @@
1004	1027	gfs2_glock_dq_uninit(&ip->i_gh);
1005	1028	}
1006	1029
1007		-static void gfs2_iomap_journaled_page_done(struct inode *inode, loff_t pos,
1008		- unsigned copied, struct page *page,
1009		- struct iomap *iomap)
	1030	+static int gfs2_iomap_page_prepare(struct inode *inode, loff_t pos,
	1031	+ unsigned len, struct iomap *iomap)
1010	1032	{
1011		- struct gfs2_inode *ip = GFS2_I(inode);
	1033	+ unsigned int blockmask = i_blocksize(inode) - 1;
	1034	+ struct gfs2_sbd *sdp = GFS2_SB(inode);
	1035	+ unsigned int blocks;
1012	1036
1013		- gfs2_page_add_databufs(ip, page, offset_in_page(pos), copied);
	1037	+ blocks = ((pos & blockmask) + len + blockmask) >> inode->i_blkbits;
	1038	+ return gfs2_trans_begin(sdp, RES_DINODE + blocks, 0);
1014	1039	}
	1040	+
	1041	+static void gfs2_iomap_page_done(struct inode *inode, loff_t pos,
	1042	+ unsigned copied, struct page *page,
	1043	+ struct iomap *iomap)
	1044	+{
	1045	+ struct gfs2_trans *tr = current->journal_info;
	1046	+ struct gfs2_inode *ip = GFS2_I(inode);
	1047	+ struct gfs2_sbd *sdp = GFS2_SB(inode);
	1048	+
	1049	+ if (page && !gfs2_is_stuffed(ip))
	1050	+ gfs2_page_add_databufs(ip, page, offset_in_page(pos), copied);
	1051	+
	1052	+ if (tr->tr_num_buf_new)
	1053	+ __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
	1054	+
	1055	+ gfs2_trans_end(sdp);
	1056	+}
	1057	+
	1058	+static const struct iomap_page_ops gfs2_iomap_page_ops = {
	1059	+ .page_prepare = gfs2_iomap_page_prepare,
	1060	+ .page_done = gfs2_iomap_page_done,
	1061	+};
1015	1062
1016	1063	static int gfs2_iomap_begin_write(struct inode *inode, loff_t pos,
1017	1064	loff_t length, unsigned flags,
..	..	@@ -1020,120 +1067,138 @@
1020	1067	{
1021	1068	struct gfs2_inode *ip = GFS2_I(inode);
1022	1069	struct gfs2_sbd *sdp = GFS2_SB(inode);
1023		- unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
1024		- bool unstuff, alloc_required;
	1070	+ bool unstuff;
1025	1071	int ret;
1026		-
1027		- ret = gfs2_write_lock(inode);
1028		- if (ret)
1029		- return ret;
1030	1072
1031	1073	unstuff = gfs2_is_stuffed(ip) &&
1032	1074	pos + length > gfs2_max_stuffed_size(ip);
1033	1075
1034		- ret = gfs2_iomap_get(inode, pos, length, flags, iomap, mp);
1035		- if (ret)
1036		- goto out_unlock;
	1076	+ if (unstuff \|\| iomap->type == IOMAP_HOLE) {
	1077	+ unsigned int data_blocks, ind_blocks;
	1078	+ struct gfs2_alloc_parms ap = {};
	1079	+ unsigned int rblocks;
	1080	+ struct gfs2_trans *tr;
1037	1081
1038		- alloc_required = unstuff \|\| iomap->type == IOMAP_HOLE;
1039		-
1040		- if (alloc_required \|\| gfs2_is_jdata(ip))
1041	1082	gfs2_write_calc_reserv(ip, iomap->length, &data_blocks,
1042	1083	&ind_blocks);
1043		-
1044		- if (alloc_required) {
1045		- struct gfs2_alloc_parms ap = {
1046		- .target = data_blocks + ind_blocks
1047		- };
1048		-
	1084	+ ap.target = data_blocks + ind_blocks;
1049	1085	ret = gfs2_quota_lock_check(ip, &ap);
1050	1086	if (ret)
1051		- goto out_unlock;
	1087	+ return ret;
1052	1088
1053	1089	ret = gfs2_inplace_reserve(ip, &ap);
1054	1090	if (ret)
1055	1091	goto out_qunlock;
1056		- }
1057	1092
1058		- rblocks = RES_DINODE + ind_blocks;
1059		- if (gfs2_is_jdata(ip))
1060		- rblocks += data_blocks;
1061		- if (ind_blocks \|\| data_blocks)
1062		- rblocks += RES_STATFS + RES_QUOTA;
1063		- if (inode == sdp->sd_rindex)
1064		- rblocks += 2 * RES_STATFS;
1065		- if (alloc_required)
	1093	+ rblocks = RES_DINODE + ind_blocks;
	1094	+ if (gfs2_is_jdata(ip))
	1095	+ rblocks += data_blocks;
	1096	+ if (ind_blocks \|\| data_blocks)
	1097	+ rblocks += RES_STATFS + RES_QUOTA;
	1098	+ if (inode == sdp->sd_rindex)
	1099	+ rblocks += 2 * RES_STATFS;
1066	1100	rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
1067	1101
1068		- ret = gfs2_trans_begin(sdp, rblocks, iomap->length >> inode->i_blkbits);
1069		- if (ret)
1070		- goto out_trans_fail;
1071		-
1072		- if (unstuff) {
1073		- ret = gfs2_unstuff_dinode(ip, NULL);
	1102	+ ret = gfs2_trans_begin(sdp, rblocks,
	1103	+ iomap->length >> inode->i_blkbits);
1074	1104	if (ret)
1075		- goto out_trans_end;
1076		- release_metapath(mp);
1077		- ret = gfs2_iomap_get(inode, iomap->offset, iomap->length,
1078		- flags, iomap, mp);
1079		- if (ret)
1080		- goto out_trans_end;
1081		- }
	1105	+ goto out_trans_fail;
1082	1106
1083		- if (iomap->type == IOMAP_HOLE) {
1084		- ret = gfs2_iomap_alloc(inode, iomap, flags, mp);
1085		- if (ret) {
1086		- gfs2_trans_end(sdp);
1087		- gfs2_inplace_release(ip);
1088		- punch_hole(ip, iomap->offset, iomap->length);
1089		- goto out_qunlock;
	1107	+ if (unstuff) {
	1108	+ ret = gfs2_unstuff_dinode(ip, NULL);
	1109	+ if (ret)
	1110	+ goto out_trans_end;
	1111	+ release_metapath(mp);
	1112	+ ret = gfs2_iomap_get(inode, iomap->offset,
	1113	+ iomap->length, flags, iomap, mp);
	1114	+ if (ret)
	1115	+ goto out_trans_end;
1090	1116	}
	1117	+
	1118	+ if (iomap->type == IOMAP_HOLE) {
	1119	+ ret = gfs2_iomap_alloc(inode, iomap, mp);
	1120	+ if (ret) {
	1121	+ gfs2_trans_end(sdp);
	1122	+ gfs2_inplace_release(ip);
	1123	+ punch_hole(ip, iomap->offset, iomap->length);
	1124	+ goto out_qunlock;
	1125	+ }
	1126	+ }
	1127	+
	1128	+ tr = current->journal_info;
	1129	+ if (tr->tr_num_buf_new)
	1130	+ __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
	1131	+
	1132	+ gfs2_trans_end(sdp);
1091	1133	}
1092		- if (!gfs2_is_stuffed(ip) && gfs2_is_jdata(ip))
1093		- iomap->page_done = gfs2_iomap_journaled_page_done;
	1134	+
	1135	+ if (gfs2_is_stuffed(ip) \|\| gfs2_is_jdata(ip))
	1136	+ iomap->page_ops = &gfs2_iomap_page_ops;
1094	1137	return 0;
1095	1138
1096	1139	out_trans_end:
1097	1140	gfs2_trans_end(sdp);
1098	1141	out_trans_fail:
1099		- if (alloc_required)
1100		- gfs2_inplace_release(ip);
	1142	+ gfs2_inplace_release(ip);
1101	1143	out_qunlock:
1102		- if (alloc_required)
1103		- gfs2_quota_unlock(ip);
1104		-out_unlock:
1105		- gfs2_write_unlock(inode);
	1144	+ gfs2_quota_unlock(ip);
1106	1145	return ret;
1107	1146	}
1108	1147
	1148	+static inline bool gfs2_iomap_need_write_lock(unsigned flags)
	1149	+{
	1150	+ return (flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT);
	1151	+}
	1152	+
1109	1153	static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
1110		- unsigned flags, struct iomap *iomap)
	1154	+ unsigned flags, struct iomap *iomap,
	1155	+ struct iomap *srcmap)
1111	1156	{
1112	1157	struct gfs2_inode *ip = GFS2_I(inode);
1113	1158	struct metapath mp = { .mp_aheight = 1, };
1114	1159	int ret;
1115	1160
1116		- iomap->flags \|= IOMAP_F_BUFFER_HEAD;
	1161	+ if (gfs2_is_jdata(ip))
	1162	+ iomap->flags \|= IOMAP_F_BUFFER_HEAD;
1117	1163
1118	1164	trace_gfs2_iomap_start(ip, pos, length, flags);
1119		- if ((flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT)) {
1120		- ret = gfs2_iomap_begin_write(inode, pos, length, flags, iomap, &mp);
1121		- } else {
1122		- ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
	1165	+ if (gfs2_iomap_need_write_lock(flags)) {
	1166	+ ret = gfs2_write_lock(inode);
	1167	+ if (ret)
	1168	+ goto out;
	1169	+ }
1123	1170
1124		- /*
1125		- * Silently fall back to buffered I/O for stuffed files or if
1126		- * we've hot a hole (see gfs2_file_direct_write).
1127		- */
1128		- if ((flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT) &&
1129		- iomap->type != IOMAP_MAPPED)
1130		- ret = -ENOTBLK;
	1171	+ ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
	1172	+ if (ret)
	1173	+ goto out_unlock;
	1174	+
	1175	+ switch(flags & (IOMAP_WRITE \| IOMAP_ZERO)) {
	1176	+ case IOMAP_WRITE:
	1177	+ if (flags & IOMAP_DIRECT) {
	1178	+ /*
	1179	+ * Silently fall back to buffered I/O for stuffed files
	1180	+ * or if we've got a hole (see gfs2_file_direct_write).
	1181	+ */
	1182	+ if (iomap->type != IOMAP_MAPPED)
	1183	+ ret = -ENOTBLK;
	1184	+ goto out_unlock;
	1185	+ }
	1186	+ break;
	1187	+ case IOMAP_ZERO:
	1188	+ if (iomap->type == IOMAP_HOLE)
	1189	+ goto out_unlock;
	1190	+ break;
	1191	+ default:
	1192	+ goto out_unlock;
1131	1193	}
1132		- if (!ret) {
1133		- get_bh(mp.mp_bh[0]);
1134		- iomap->private = mp.mp_bh[0];
1135		- }
	1194	+
	1195	+ ret = gfs2_iomap_begin_write(inode, pos, length, flags, iomap, &mp);
	1196	+
	1197	+out_unlock:
	1198	+ if (ret && gfs2_iomap_need_write_lock(flags))
	1199	+ gfs2_write_unlock(inode);
1136	1200	release_metapath(&mp);
	1201	+out:
1137	1202	trace_gfs2_iomap_end(ip, iomap, ret);
1138	1203	return ret;
1139	1204	}
..	..	@@ -1143,48 +1208,52 @@
1143	1208	{
1144	1209	struct gfs2_inode *ip = GFS2_I(inode);
1145	1210	struct gfs2_sbd *sdp = GFS2_SB(inode);
1146		- struct gfs2_trans *tr = current->journal_info;
1147		- struct buffer_head *dibh = iomap->private;
1148	1211
1149		- if ((flags & (IOMAP_WRITE \| IOMAP_DIRECT)) != IOMAP_WRITE)
1150		- goto out;
	1212	+ switch (flags & (IOMAP_WRITE \| IOMAP_ZERO)) {
	1213	+ case IOMAP_WRITE:
	1214	+ if (flags & IOMAP_DIRECT)
	1215	+ return 0;
	1216	+ break;
	1217	+ case IOMAP_ZERO:
	1218	+ if (iomap->type == IOMAP_HOLE)
	1219	+ return 0;
	1220	+ break;
	1221	+ default:
	1222	+ return 0;
	1223	+ }
1151	1224
1152		- if (iomap->type != IOMAP_INLINE) {
	1225	+ if (!gfs2_is_stuffed(ip))
1153	1226	gfs2_ordered_add_inode(ip);
1154	1227
1155		- if (tr->tr_num_buf_new)
1156		- __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1157		- else
1158		- gfs2_trans_add_meta(ip->i_gl, dibh);
1159		- }
1160		-
1161		- if (inode == sdp->sd_rindex) {
	1228	+ if (inode == sdp->sd_rindex)
1162	1229	adjust_fs_space(inode);
1163		- sdp->sd_rindex_uptodate = 0;
1164		- }
1165	1230
1166		- gfs2_trans_end(sdp);
1167	1231	gfs2_inplace_release(ip);
1168		-
1169		- if (length != written && (iomap->flags & IOMAP_F_NEW)) {
1170		- /* Deallocate blocks that were just allocated. */
1171		- loff_t blockmask = i_blocksize(inode) - 1;
1172		- loff_t end = (pos + length) & ~blockmask;
1173		-
1174		- pos = (pos + written + blockmask) & ~blockmask;
1175		- if (pos < end) {
1176		- truncate_pagecache_range(inode, pos, end - 1);
1177		- punch_hole(ip, pos, end - pos);
1178		- }
1179		- }
1180	1232
1181	1233	if (ip->i_qadata && ip->i_qadata->qa_qd_num)
1182	1234	gfs2_quota_unlock(ip);
1183		- gfs2_write_unlock(inode);
1184	1235
1185		-out:
1186		- if (dibh)
1187		- brelse(dibh);
	1236	+ if (length != written && (iomap->flags & IOMAP_F_NEW)) {
	1237	+ /* Deallocate blocks that were just allocated. */
	1238	+ loff_t hstart = round_up(pos + written, i_blocksize(inode));
	1239	+ loff_t hend = iomap->offset + iomap->length;
	1240	+
	1241	+ if (hstart < hend) {
	1242	+ truncate_pagecache_range(inode, hstart, hend - 1);
	1243	+ punch_hole(ip, hstart, hend - hstart);
	1244	+ }
	1245	+ }
	1246	+
	1247	+ if (unlikely(!written))
	1248	+ goto out_unlock;
	1249	+
	1250	+ if (iomap->flags & IOMAP_F_SIZE_CHANGED)
	1251	+ mark_inode_dirty(inode);
	1252	+ set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
	1253	+
	1254	+out_unlock:
	1255	+ if (gfs2_iomap_need_write_lock(flags))
	1256	+ gfs2_write_unlock(inode);
1188	1257	return 0;
1189	1258	}
1190	1259
..	..	@@ -1222,6 +1291,7 @@
1222	1291	loff_t length = bh_map->b_size;
1223	1292	struct metapath mp = { .mp_aheight = 1, };
1224	1293	struct iomap iomap = { };
	1294	+ int flags = create ? IOMAP_WRITE : 0;
1225	1295	int ret;
1226	1296
1227	1297	clear_buffer_mapped(bh_map);
..	..	@@ -1229,15 +1299,10 @@
1229	1299	clear_buffer_boundary(bh_map);
1230	1300	trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
1231	1301
1232		- if (create) {
1233		- ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, &iomap, &mp);
1234		- if (!ret && iomap.type == IOMAP_HOLE)
1235		- ret = gfs2_iomap_alloc(inode, &iomap, IOMAP_WRITE, &mp);
1236		- release_metapath(&mp);
1237		- } else {
1238		- ret = gfs2_iomap_get(inode, pos, length, 0, &iomap, &mp);
1239		- release_metapath(&mp);
1240		- }
	1302	+ ret = gfs2_iomap_get(inode, pos, length, flags, &iomap, &mp);
	1303	+ if (create && !ret && iomap.type == IOMAP_HOLE)
	1304	+ ret = gfs2_iomap_alloc(inode, &iomap, &mp);
	1305	+ release_metapath(&mp);
1241	1306	if (ret)
1242	1307	goto out;
1243	1308
..	..	@@ -1282,76 +1347,16 @@
1282	1347	return ret;
1283	1348	}
1284	1349
1285		-/**
1286		- * gfs2_block_zero_range - Deal with zeroing out data
1287		- *
1288		- * This is partly borrowed from ext3.
	1350	+/*
	1351	+ * NOTE: Never call gfs2_block_zero_range with an open transaction because it
	1352	+ * uses iomap write to perform its actions, which begin their own transactions
	1353	+ * (iomap_begin, page_prepare, etc.)
1289	1354	*/
1290	1355	static int gfs2_block_zero_range(struct inode *inode, loff_t from,
1291	1356	unsigned int length)
1292	1357	{
1293		- struct address_space *mapping = inode->i_mapping;
1294		- struct gfs2_inode *ip = GFS2_I(inode);
1295		- unsigned long index = from >> PAGE_SHIFT;
1296		- unsigned offset = from & (PAGE_SIZE-1);
1297		- unsigned blocksize, iblock, pos;
1298		- struct buffer_head *bh;
1299		- struct page *page;
1300		- int err;
1301		-
1302		- page = find_or_create_page(mapping, index, GFP_NOFS);
1303		- if (!page)
1304		- return 0;
1305		-
1306		- blocksize = inode->i_sb->s_blocksize;
1307		- iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
1308		-
1309		- if (!page_has_buffers(page))
1310		- create_empty_buffers(page, blocksize, 0);
1311		-
1312		- /* Find the buffer that contains "offset" */
1313		- bh = page_buffers(page);
1314		- pos = blocksize;
1315		- while (offset >= pos) {
1316		- bh = bh->b_this_page;
1317		- iblock++;
1318		- pos += blocksize;
1319		- }
1320		-
1321		- err = 0;
1322		-
1323		- if (!buffer_mapped(bh)) {
1324		- gfs2_block_map(inode, iblock, bh, 0);
1325		- /* unmapped? It's a hole - nothing to do */
1326		- if (!buffer_mapped(bh))
1327		- goto unlock;
1328		- }
1329		-
1330		- /* Ok, it's mapped. Make sure it's up-to-date */
1331		- if (PageUptodate(page))
1332		- set_buffer_uptodate(bh);
1333		-
1334		- if (!buffer_uptodate(bh)) {
1335		- err = -EIO;
1336		- ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1337		- wait_on_buffer(bh);
1338		- /* Uhhuh. Read error. Complain and punt. */
1339		- if (!buffer_uptodate(bh))
1340		- goto unlock;
1341		- err = 0;
1342		- }
1343		-
1344		- if (gfs2_is_jdata(ip))
1345		- gfs2_trans_add_data(ip->i_gl, bh);
1346		- else
1347		- gfs2_ordered_add_inode(ip);
1348		-
1349		- zero_user(page, offset, length);
1350		- mark_buffer_dirty(bh);
1351		-unlock:
1352		- unlock_page(page);
1353		- put_page(page);
1354		- return err;
	1358	+ BUG_ON(current->journal_info);
	1359	+ return iomap_zero_range(inode, from, length, NULL, &gfs2_iomap_ops);
1355	1360	}
1356	1361
1357	1362	#define GFS2_JTRUNC_REVOKES 8192
..	..	@@ -1411,6 +1416,16 @@
1411	1416	u64 oldsize = inode->i_size;
1412	1417	int error;
1413	1418
	1419	+ if (!gfs2_is_stuffed(ip)) {
	1420	+ unsigned int blocksize = i_blocksize(inode);
	1421	+ unsigned int offs = newsize & (blocksize - 1);
	1422	+ if (offs) {
	1423	+ error = gfs2_block_zero_range(inode, newsize,
	1424	+ blocksize - offs);
	1425	+ if (error)
	1426	+ return error;
	1427	+ }
	1428	+ }
1414	1429	if (journaled)
1415	1430	error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1416	1431	else
..	..	@@ -1424,19 +1439,10 @@
1424	1439
1425	1440	gfs2_trans_add_meta(ip->i_gl, dibh);
1426	1441
1427		- if (gfs2_is_stuffed(ip)) {
	1442	+ if (gfs2_is_stuffed(ip))
1428	1443	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1429		- } else {
1430		- unsigned int blocksize = i_blocksize(inode);
1431		- unsigned int offs = newsize & (blocksize - 1);
1432		- if (offs) {
1433		- error = gfs2_block_zero_range(inode, newsize,
1434		- blocksize - offs);
1435		- if (error)
1436		- goto out;
1437		- }
	1444	+ else
1438	1445	ip->i_diskflags \|= GFS2_DIF_TRUNC_IN_PROG;
1439		- }
1440	1446
1441	1447	i_size_write(inode, newsize);
1442	1448	ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
..	..	@@ -1462,7 +1468,7 @@
1462	1468
1463	1469	ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, iomap, &mp);
1464	1470	if (!ret && iomap->type == IOMAP_HOLE)
1465		- ret = gfs2_iomap_alloc(inode, iomap, IOMAP_WRITE, &mp);
	1471	+ ret = gfs2_iomap_alloc(inode, iomap, &mp);
1466	1472	release_metapath(&mp);
1467	1473	return ret;
1468	1474	}
..	..	@@ -1600,7 +1606,7 @@
1600	1606	continue;
1601	1607	}
1602	1608	if (bstart) {
1603		- __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
	1609	+ __gfs2_free_blocks(ip, rgd, bstart, (u32)blen, meta);
1604	1610	(*btotal) += blen;
1605	1611	gfs2_add_inode_blocks(&ip->i_inode, -blen);
1606	1612	}
..	..	@@ -1608,7 +1614,7 @@
1608	1614	blen = 1;
1609	1615	}
1610	1616	if (bstart) {
1611		- __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
	1617	+ __gfs2_free_blocks(ip, rgd, bstart, (u32)blen, meta);
1612	1618	(*btotal) += blen;
1613	1619	gfs2_add_inode_blocks(&ip->i_inode, -blen);
1614	1620	}
..	..	@@ -1758,7 +1764,7 @@
1758	1764	u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
1759	1765	__u16 start_list[GFS2_MAX_META_HEIGHT];
1760	1766	__u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
1761		- unsigned int start_aligned, uninitialized_var(end_aligned);
	1767	+ unsigned int start_aligned, end_aligned;
1762	1768	unsigned int strip_h = ip->i_height - 1;
1763	1769	u32 btotal = 0;
1764	1770	int ret, state;
..	..	@@ -1863,9 +1869,8 @@
1863	1869	gfs2_assert_withdraw(sdp, bh);
1864	1870	if (gfs2_assert_withdraw(sdp,
1865	1871	prev_bnr != bh->b_blocknr)) {
1866		- printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1867		- "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1868		- sdp->sd_fsname,
	1872	+ fs_emerg(sdp, "inode %llu, block:%llu, i_h:%u,"
	1873	+ "s_h:%u, mp_h:%u\n",
1869	1874	(unsigned long long)ip->i_no_addr,
1870	1875	prev_bnr, ip->i_height, strip_h, mp_h);
1871	1876	}
..	..	@@ -2141,7 +2146,7 @@
2141	2146	if (error)
2142	2147	goto do_end_trans;
2143	2148
2144		- i_size_write(inode, size);
	2149	+ truncate_setsize(inode, size);
2145	2150	ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
2146	2151	gfs2_trans_add_meta(ip->i_gl, dibh);
2147	2152	gfs2_dinode_out(ip, dibh->b_data);
..	..	@@ -2183,7 +2188,7 @@
2183	2188
2184	2189	inode_dio_wait(inode);
2185	2190
2186		- ret = gfs2_rsqa_alloc(ip);
	2191	+ ret = gfs2_qa_get(ip);
2187	2192	if (ret)
2188	2193	goto out;
2189	2194
..	..	@@ -2194,7 +2199,8 @@
2194	2199
2195	2200	ret = do_shrink(inode, newsize);
2196	2201	out:
2197		- gfs2_rsqa_delete(ip, NULL);
	2202	+ gfs2_rs_delete(ip);
	2203	+ gfs2_qa_put(ip);
2198	2204	return ret;
2199	2205	}
2200	2206
..	..	@@ -2223,7 +2229,7 @@
2223	2229	struct gfs2_journal_extent *jext;
2224	2230
2225	2231	while(!list_empty(&jd->extent_list)) {
2226		- jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
	2232	+ jext = list_first_entry(&jd->extent_list, struct gfs2_journal_extent, list);
2227	2233	list_del(&jext->list);
2228	2234	kfree(jext);
2229	2235	}
..	..	@@ -2244,7 +2250,7 @@
2244	2250	struct gfs2_journal_extent *jext;
2245	2251
2246	2252	if (!list_empty(&jd->extent_list)) {
2247		- jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
	2253	+ jext = list_last_entry(&jd->extent_list, struct gfs2_journal_extent, list);
2248	2254	if ((jext->dblock + jext->blocks) == dblock) {
2249	2255	jext->blocks += blocks;
2250	2256	return 0;
..	..	@@ -2291,7 +2297,9 @@
2291	2297	unsigned int shift = sdp->sd_sb.sb_bsize_shift;
2292	2298	u64 size;
2293	2299	int rc;
	2300	+ ktime_t start, end;
2294	2301
	2302	+ start = ktime_get();
2295	2303	lblock_stop = i_size_read(jd->jd_inode) >> shift;
2296	2304	size = (lblock_stop - lblock) << shift;
2297	2305	jd->nr_extents = 0;
..	..	@@ -2311,8 +2319,9 @@
2311	2319	lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2312	2320	} while(size > 0);
2313	2321
2314		- fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
2315		- jd->nr_extents);
	2322	+ end = ktime_get();
	2323	+ fs_info(sdp, "journal %d mapped with %u extents in %lldms\n", jd->jd_jid,
	2324	+ jd->nr_extents, ktime_ms_delta(end, start));
2316	2325	return 0;
2317	2326
2318	2327	fail:
..	..	@@ -2438,24 +2447,13 @@
2438	2447	struct inode *inode = file_inode(file);
2439	2448	struct gfs2_inode *ip = GFS2_I(inode);
2440	2449	struct gfs2_sbd *sdp = GFS2_SB(inode);
	2450	+ unsigned int blocksize = i_blocksize(inode);
	2451	+ loff_t start, end;
2441	2452	int error;
2442	2453
2443		- if (gfs2_is_jdata(ip))
2444		- error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
2445		- GFS2_JTRUNC_REVOKES);
2446		- else
2447		- error = gfs2_trans_begin(sdp, RES_DINODE, 0);
2448		- if (error)
2449		- return error;
	2454	+ if (!gfs2_is_stuffed(ip)) {
	2455	+ unsigned int start_off, end_len;
2450	2456
2451		- if (gfs2_is_stuffed(ip)) {
2452		- error = stuffed_zero_range(inode, offset, length);
2453		- if (error)
2454		- goto out;
2455		- } else {
2456		- unsigned int start_off, end_len, blocksize;
2457		-
2458		- blocksize = i_blocksize(inode);
2459	2457	start_off = offset & (blocksize - 1);
2460	2458	end_len = (offset + length) & (blocksize - 1);
2461	2459	if (start_off) {
..	..	@@ -2474,6 +2472,26 @@
2474	2472	if (error)
2475	2473	goto out;
2476	2474	}
	2475	+ }
	2476	+
	2477	+ start = round_down(offset, blocksize);
	2478	+ end = round_up(offset + length, blocksize) - 1;
	2479	+ error = filemap_write_and_wait_range(inode->i_mapping, start, end);
	2480	+ if (error)
	2481	+ return error;
	2482	+
	2483	+ if (gfs2_is_jdata(ip))
	2484	+ error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
	2485	+ GFS2_JTRUNC_REVOKES);
	2486	+ else
	2487	+ error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	2488	+ if (error)
	2489	+ return error;
	2490	+
	2491	+ if (gfs2_is_stuffed(ip)) {
	2492	+ error = stuffed_zero_range(inode, offset, length);
	2493	+ if (error)
	2494	+ goto out;
2477	2495	}
2478	2496
2479	2497	if (gfs2_is_jdata(ip)) {
..	..	@@ -2496,3 +2514,26 @@
2496	2514	gfs2_trans_end(sdp);
2497	2515	return error;
2498	2516	}
	2517	+
	2518	+static int gfs2_map_blocks(struct iomap_writepage_ctx wpc, struct inode inode,
	2519	+ loff_t offset)
	2520	+{
	2521	+ struct metapath mp = { .mp_aheight = 1, };
	2522	+ int ret;
	2523	+
	2524	+ if (WARN_ON_ONCE(gfs2_is_stuffed(GFS2_I(inode))))
	2525	+ return -EIO;
	2526	+
	2527	+ if (offset >= wpc->iomap.offset &&
	2528	+ offset < wpc->iomap.offset + wpc->iomap.length)
	2529	+ return 0;
	2530	+
	2531	+ memset(&wpc->iomap, 0, sizeof(wpc->iomap));
	2532	+ ret = gfs2_iomap_get(inode, offset, INT_MAX, 0, &wpc->iomap, &mp);
	2533	+ release_metapath(&mp);
	2534	+ return ret;
	2535	+}
	2536	+
	2537	+const struct iomap_writeback_ops gfs2_writeback_ops = {
	2538	+ .map_blocks = gfs2_map_blocks,
	2539	+};