~hc/RK356X_SDK_RELEASE.git

..	..	@@ -10,55 +10,15 @@
10	10	#include "xfs_log_format.h"
11	11	#include "xfs_trans_resv.h"
12	12	#include "xfs_mount.h"
13		-#include "xfs_defer.h"
14	13	#include "xfs_inode.h"
15	14	#include "xfs_errortag.h"
16	15	#include "xfs_error.h"
17		-#include "xfs_cksum.h"
18	16	#include "xfs_icache.h"
19	17	#include "xfs_trans.h"
20	18	#include "xfs_ialloc.h"
21	19	#include "xfs_dir2.h"
22	20
23	21	#include <linux/iversion.h>
24		-
25		-/*
26		- * Check that none of the inode's in the buffer have a next
27		- * unlinked field of 0.
28		- */
29		-#if defined(DEBUG)
30		-void
31		-xfs_inobp_check(
32		- xfs_mount_t *mp,
33		- xfs_buf_t *bp)
34		-{
35		- int i;
36		- int j;
37		- xfs_dinode_t *dip;
38		-
39		- j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
40		-
41		- for (i = 0; i < j; i++) {
42		- dip = xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize);
43		- if (!dip->di_next_unlinked) {
44		- xfs_alert(mp,
45		- "Detected bogus zero next_unlinked field in inode %d buffer 0x%llx.",
46		- i, (long long)bp->b_bn);
47		- }
48		- }
49		-}
50		-#endif
51		-
52		-bool
53		-xfs_dinode_good_version(
54		- struct xfs_mount *mp,
55		- __u8 version)
56		-{
57		- if (xfs_sb_version_hascrc(&mp->m_sb))
58		- return version == 3;
59		-
60		- return version == 1 \|\| version == 2;
61		-}
62	22
63	23	/*
64	24	* If we are doing readahead on an inode buffer, we might be in log recovery
..	..	@@ -69,10 +29,10 @@
69	29	* If the readahead buffer is invalid, we need to mark it with an error and
70	30	* clear the DONE status of the buffer so that a followup read will re-read it
71	31	* from disk. We don't report the error otherwise to avoid warnings during log
72		- * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
	32	+ * recovery and we don't get unnecessary panics on debug kernels. We use EIO here
73	33	* because all we want to do is say readahead failed; there is no-one to report
74	34	* the error to, so this will distinguish it from a non-ra verifier failure.
75		- * Changes to this readahead error behavour also need to be reflected in
	35	+ * Changes to this readahead error behaviour also need to be reflected in
76	36	* xfs_dquot_buf_readahead_verify().
77	37	*/
78	38	static void
..	..	@@ -80,7 +40,7 @@
80	40	struct xfs_buf *bp,
81	41	bool readahead)
82	42	{
83		- struct xfs_mount *mp = bp->b_target->bt_mount;
	43	+ struct xfs_mount *mp = bp->b_mount;
84	44	xfs_agnumber_t agno;
85	45	int i;
86	46	int ni;
..	..	@@ -97,10 +57,9 @@
97	57
98	58	dip = xfs_buf_offset(bp, (i << mp->m_sb.sb_inodelog));
99	59	unlinked_ino = be32_to_cpu(dip->di_next_unlinked);
100		- di_ok = dip->di_magic == cpu_to_be16(XFS_DINODE_MAGIC) &&
101		- xfs_dinode_good_version(mp, dip->di_version) &&
102		- (unlinked_ino == NULLAGINO \|\|
103		- xfs_verify_agino(mp, agno, unlinked_ino));
	60	+ di_ok = xfs_verify_magic16(bp, dip->di_magic) &&
	61	+ xfs_dinode_good_version(&mp->m_sb, dip->di_version) &&
	62	+ xfs_verify_agino_or_null(mp, agno, unlinked_ino);
104	63	if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
105	64	XFS_ERRTAG_ITOBP_INOTOBP))) {
106	65	if (readahead) {
..	..	@@ -147,12 +106,16 @@
147	106
148	107	const struct xfs_buf_ops xfs_inode_buf_ops = {
149	108	.name = "xfs_inode",
	109	+ .magic16 = { cpu_to_be16(XFS_DINODE_MAGIC),
	110	+ cpu_to_be16(XFS_DINODE_MAGIC) },
150	111	.verify_read = xfs_inode_buf_read_verify,
151	112	.verify_write = xfs_inode_buf_write_verify,
152	113	};
153	114
154	115	const struct xfs_buf_ops xfs_inode_buf_ra_ops = {
155		- .name = "xxfs_inode_ra",
	116	+ .name = "xfs_inode_ra",
	117	+ .magic16 = { cpu_to_be16(XFS_DINODE_MAGIC),
	118	+ cpu_to_be16(XFS_DINODE_MAGIC) },
156	119	.verify_read = xfs_inode_buf_readahead_verify,
157	120	.verify_write = xfs_inode_buf_write_verify,
158	121	};
..	..	@@ -174,8 +137,7 @@
174	137	struct xfs_imap *imap,
175	138	struct xfs_dinode **dipp,
176	139	struct xfs_buf **bpp,
177		- uint buf_flags,
178		- uint iget_flags)
	140	+ uint buf_flags)
179	141	{
180	142	struct xfs_buf *bp;
181	143	int error;
..	..	@@ -185,49 +147,93 @@
185	147	(int)imap->im_len, buf_flags, &bp,
186	148	&xfs_inode_buf_ops);
187	149	if (error) {
188		- if (error == -EAGAIN) {
189		- ASSERT(buf_flags & XBF_TRYLOCK);
190		- return error;
191		- }
192		- xfs_warn(mp, "%s: xfs_trans_read_buf() returned error %d.",
193		- __func__, error);
	150	+ ASSERT(error != -EAGAIN \|\| (buf_flags & XBF_TRYLOCK));
194	151	return error;
195	152	}
196	153
197	154	*bpp = bp;
198		- *dipp = xfs_buf_offset(bp, imap->im_boffset);
	155	+ if (dipp)
	156	+ *dipp = xfs_buf_offset(bp, imap->im_boffset);
199	157	return 0;
200	158	}
201	159
202		-void
	160	+static inline struct timespec64 xfs_inode_decode_bigtime(uint64_t ts)
	161	+{
	162	+ struct timespec64 tv;
	163	+ uint32_t n;
	164	+
	165	+ tv.tv_sec = xfs_bigtime_to_unix(div_u64_rem(ts, NSEC_PER_SEC, &n));
	166	+ tv.tv_nsec = n;
	167	+
	168	+ return tv;
	169	+}
	170	+
	171	+/* Convert an ondisk timestamp to an incore timestamp. */
	172	+struct timespec64
	173	+xfs_inode_from_disk_ts(
	174	+ struct xfs_dinode *dip,
	175	+ const xfs_timestamp_t ts)
	176	+{
	177	+ struct timespec64 tv;
	178	+ struct xfs_legacy_timestamp *lts;
	179	+
	180	+ if (xfs_dinode_has_bigtime(dip))
	181	+ return xfs_inode_decode_bigtime(be64_to_cpu(ts));
	182	+
	183	+ lts = (struct xfs_legacy_timestamp *)&ts;
	184	+ tv.tv_sec = (int)be32_to_cpu(lts->t_sec);
	185	+ tv.tv_nsec = (int)be32_to_cpu(lts->t_nsec);
	186	+
	187	+ return tv;
	188	+}
	189	+
	190	+int
203	191	xfs_inode_from_disk(
204	192	struct xfs_inode *ip,
205	193	struct xfs_dinode *from)
206	194	{
207	195	struct xfs_icdinode *to = &ip->i_d;
208	196	struct inode *inode = VFS_I(ip);
	197	+ int error;
	198	+ xfs_failaddr_t fa;
209	199
	200	+ ASSERT(ip->i_cowfp == NULL);
	201	+ ASSERT(ip->i_afp == NULL);
	202	+
	203	+ fa = xfs_dinode_verify(ip->i_mount, ip->i_ino, from);
	204	+ if (fa) {
	205	+ xfs_inode_verifier_error(ip, -EFSCORRUPTED, "dinode", from,
	206	+ sizeof(*from), fa);
	207	+ return -EFSCORRUPTED;
	208	+ }
	209	+
	210	+ /*
	211	+ * First get the permanent information that is needed to allocate an
	212	+ * inode. If the inode is unused, mode is zero and we shouldn't mess
	213	+ * with the uninitialized part of it.
	214	+ */
	215	+ to->di_flushiter = be16_to_cpu(from->di_flushiter);
	216	+ inode->i_generation = be32_to_cpu(from->di_gen);
	217	+ inode->i_mode = be16_to_cpu(from->di_mode);
	218	+ if (!inode->i_mode)
	219	+ return 0;
210	220
211	221	/*
212	222	* Convert v1 inodes immediately to v2 inode format as this is the
213	223	* minimum inode version format we support in the rest of the code.
	224	+ * They will also be unconditionally written back to disk as v2 inodes.
214	225	*/
215		- to->di_version = from->di_version;
216		- if (to->di_version == 1) {
	226	+ if (unlikely(from->di_version == 1)) {
217	227	set_nlink(inode, be16_to_cpu(from->di_onlink));
218		- to->di_projid_lo = 0;
219		- to->di_projid_hi = 0;
220		- to->di_version = 2;
	228	+ to->di_projid = 0;
221	229	} else {
222	230	set_nlink(inode, be32_to_cpu(from->di_nlink));
223		- to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
224		- to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
	231	+ to->di_projid = (prid_t)be16_to_cpu(from->di_projid_hi) << 16 \|
	232	+ be16_to_cpu(from->di_projid_lo);
225	233	}
226	234
227		- to->di_format = from->di_format;
228		- to->di_uid = be32_to_cpu(from->di_uid);
229		- to->di_gid = be32_to_cpu(from->di_gid);
230		- to->di_flushiter = be16_to_cpu(from->di_flushiter);
	235	+ i_uid_write(inode, be32_to_cpu(from->di_uid));
	236	+ i_gid_write(inode, be32_to_cpu(from->di_gid));
231	237
232	238	/*
233	239	* Time is signed, so need to convert to signed 32 bit before
..	..	@@ -235,34 +241,60 @@
235	241	* a time before epoch is converted to a time long after epoch
236	242	* on 64 bit systems.
237	243	*/
238		- inode->i_atime.tv_sec = (int)be32_to_cpu(from->di_atime.t_sec);
239		- inode->i_atime.tv_nsec = (int)be32_to_cpu(from->di_atime.t_nsec);
240		- inode->i_mtime.tv_sec = (int)be32_to_cpu(from->di_mtime.t_sec);
241		- inode->i_mtime.tv_nsec = (int)be32_to_cpu(from->di_mtime.t_nsec);
242		- inode->i_ctime.tv_sec = (int)be32_to_cpu(from->di_ctime.t_sec);
243		- inode->i_ctime.tv_nsec = (int)be32_to_cpu(from->di_ctime.t_nsec);
244		- inode->i_generation = be32_to_cpu(from->di_gen);
245		- inode->i_mode = be16_to_cpu(from->di_mode);
	244	+ inode->i_atime = xfs_inode_from_disk_ts(from, from->di_atime);
	245	+ inode->i_mtime = xfs_inode_from_disk_ts(from, from->di_mtime);
	246	+ inode->i_ctime = xfs_inode_from_disk_ts(from, from->di_ctime);
246	247
247	248	to->di_size = be64_to_cpu(from->di_size);
248	249	to->di_nblocks = be64_to_cpu(from->di_nblocks);
249	250	to->di_extsize = be32_to_cpu(from->di_extsize);
250		- to->di_nextents = be32_to_cpu(from->di_nextents);
251		- to->di_anextents = be16_to_cpu(from->di_anextents);
252	251	to->di_forkoff = from->di_forkoff;
253		- to->di_aformat = from->di_aformat;
254	252	to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
255	253	to->di_dmstate = be16_to_cpu(from->di_dmstate);
256	254	to->di_flags = be16_to_cpu(from->di_flags);
257	255
258		- if (to->di_version == 3) {
	256	+ if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) {
259	257	inode_set_iversion_queried(inode,
260	258	be64_to_cpu(from->di_changecount));
261		- to->di_crtime.t_sec = be32_to_cpu(from->di_crtime.t_sec);
262		- to->di_crtime.t_nsec = be32_to_cpu(from->di_crtime.t_nsec);
	259	+ to->di_crtime = xfs_inode_from_disk_ts(from, from->di_crtime);
263	260	to->di_flags2 = be64_to_cpu(from->di_flags2);
264	261	to->di_cowextsize = be32_to_cpu(from->di_cowextsize);
265	262	}
	263	+
	264	+ error = xfs_iformat_data_fork(ip, from);
	265	+ if (error)
	266	+ return error;
	267	+ if (from->di_forkoff) {
	268	+ error = xfs_iformat_attr_fork(ip, from);
	269	+ if (error)
	270	+ goto out_destroy_data_fork;
	271	+ }
	272	+ if (xfs_is_reflink_inode(ip))
	273	+ xfs_ifork_init_cow(ip);
	274	+ return 0;
	275	+
	276	+out_destroy_data_fork:
	277	+ xfs_idestroy_fork(&ip->i_df);
	278	+ return error;
	279	+}
	280	+
	281	+/* Convert an incore timestamp to an ondisk timestamp. */
	282	+static inline xfs_timestamp_t
	283	+xfs_inode_to_disk_ts(
	284	+ struct xfs_inode *ip,
	285	+ const struct timespec64 tv)
	286	+{
	287	+ struct xfs_legacy_timestamp *lts;
	288	+ xfs_timestamp_t ts;
	289	+
	290	+ if (xfs_inode_has_bigtime(ip))
	291	+ return cpu_to_be64(xfs_inode_encode_bigtime(tv));
	292	+
	293	+ lts = (struct xfs_legacy_timestamp *)&ts;
	294	+ lts->t_sec = cpu_to_be32(tv.tv_sec);
	295	+ lts->t_nsec = cpu_to_be32(tv.tv_nsec);
	296	+
	297	+ return ts;
266	298	}
267	299
268	300	void
..	..	@@ -277,20 +309,16 @@
277	309	to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
278	310	to->di_onlink = 0;
279	311
280		- to->di_version = from->di_version;
281		- to->di_format = from->di_format;
282		- to->di_uid = cpu_to_be32(from->di_uid);
283		- to->di_gid = cpu_to_be32(from->di_gid);
284		- to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
285		- to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
	312	+ to->di_format = xfs_ifork_format(&ip->i_df);
	313	+ to->di_uid = cpu_to_be32(i_uid_read(inode));
	314	+ to->di_gid = cpu_to_be32(i_gid_read(inode));
	315	+ to->di_projid_lo = cpu_to_be16(from->di_projid & 0xffff);
	316	+ to->di_projid_hi = cpu_to_be16(from->di_projid >> 16);
286	317
287	318	memset(to->di_pad, 0, sizeof(to->di_pad));
288		- to->di_atime.t_sec = cpu_to_be32(inode->i_atime.tv_sec);
289		- to->di_atime.t_nsec = cpu_to_be32(inode->i_atime.tv_nsec);
290		- to->di_mtime.t_sec = cpu_to_be32(inode->i_mtime.tv_sec);
291		- to->di_mtime.t_nsec = cpu_to_be32(inode->i_mtime.tv_nsec);
292		- to->di_ctime.t_sec = cpu_to_be32(inode->i_ctime.tv_sec);
293		- to->di_ctime.t_nsec = cpu_to_be32(inode->i_ctime.tv_nsec);
	319	+ to->di_atime = xfs_inode_to_disk_ts(ip, inode->i_atime);
	320	+ to->di_mtime = xfs_inode_to_disk_ts(ip, inode->i_mtime);
	321	+ to->di_ctime = xfs_inode_to_disk_ts(ip, inode->i_ctime);
294	322	to->di_nlink = cpu_to_be32(inode->i_nlink);
295	323	to->di_gen = cpu_to_be32(inode->i_generation);
296	324	to->di_mode = cpu_to_be16(inode->i_mode);
..	..	@@ -298,18 +326,18 @@
298	326	to->di_size = cpu_to_be64(from->di_size);
299	327	to->di_nblocks = cpu_to_be64(from->di_nblocks);
300	328	to->di_extsize = cpu_to_be32(from->di_extsize);
301		- to->di_nextents = cpu_to_be32(from->di_nextents);
302		- to->di_anextents = cpu_to_be16(from->di_anextents);
	329	+ to->di_nextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_df));
	330	+ to->di_anextents = cpu_to_be16(xfs_ifork_nextents(ip->i_afp));
303	331	to->di_forkoff = from->di_forkoff;
304		- to->di_aformat = from->di_aformat;
	332	+ to->di_aformat = xfs_ifork_format(ip->i_afp);
305	333	to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
306	334	to->di_dmstate = cpu_to_be16(from->di_dmstate);
307	335	to->di_flags = cpu_to_be16(from->di_flags);
308	336
309		- if (from->di_version == 3) {
	337	+ if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) {
	338	+ to->di_version = 3;
310	339	to->di_changecount = cpu_to_be64(inode_peek_iversion(inode));
311		- to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);
312		- to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);
	340	+ to->di_crtime = xfs_inode_to_disk_ts(ip, from->di_crtime);
313	341	to->di_flags2 = cpu_to_be64(from->di_flags2);
314	342	to->di_cowextsize = cpu_to_be32(from->di_cowextsize);
315	343	to->di_ino = cpu_to_be64(ip->i_ino);
..	..	@@ -318,58 +346,7 @@
318	346	uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
319	347	to->di_flushiter = 0;
320	348	} else {
321		- to->di_flushiter = cpu_to_be16(from->di_flushiter);
322		- }
323		-}
324		-
325		-void
326		-xfs_log_dinode_to_disk(
327		- struct xfs_log_dinode *from,
328		- struct xfs_dinode *to)
329		-{
330		- to->di_magic = cpu_to_be16(from->di_magic);
331		- to->di_mode = cpu_to_be16(from->di_mode);
332		- to->di_version = from->di_version;
333		- to->di_format = from->di_format;
334		- to->di_onlink = 0;
335		- to->di_uid = cpu_to_be32(from->di_uid);
336		- to->di_gid = cpu_to_be32(from->di_gid);
337		- to->di_nlink = cpu_to_be32(from->di_nlink);
338		- to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
339		- to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
340		- memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
341		-
342		- to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
343		- to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
344		- to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
345		- to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
346		- to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
347		- to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
348		-
349		- to->di_size = cpu_to_be64(from->di_size);
350		- to->di_nblocks = cpu_to_be64(from->di_nblocks);
351		- to->di_extsize = cpu_to_be32(from->di_extsize);
352		- to->di_nextents = cpu_to_be32(from->di_nextents);
353		- to->di_anextents = cpu_to_be16(from->di_anextents);
354		- to->di_forkoff = from->di_forkoff;
355		- to->di_aformat = from->di_aformat;
356		- to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
357		- to->di_dmstate = cpu_to_be16(from->di_dmstate);
358		- to->di_flags = cpu_to_be16(from->di_flags);
359		- to->di_gen = cpu_to_be32(from->di_gen);
360		-
361		- if (from->di_version == 3) {
362		- to->di_changecount = cpu_to_be64(from->di_changecount);
363		- to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);
364		- to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);
365		- to->di_flags2 = cpu_to_be64(from->di_flags2);
366		- to->di_cowextsize = cpu_to_be32(from->di_cowextsize);
367		- to->di_ino = cpu_to_be64(from->di_ino);
368		- to->di_lsn = cpu_to_be64(from->di_lsn);
369		- memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
370		- uuid_copy(&to->di_uuid, &from->di_uuid);
371		- to->di_flushiter = 0;
372		- } else {
	349	+ to->di_version = 2;
373	350	to->di_flushiter = cpu_to_be16(from->di_flushiter);
374	351	}
375	352	}
..	..	@@ -381,19 +358,36 @@
381	358	int whichfork)
382	359	{
383	360	uint32_t di_nextents = XFS_DFORK_NEXTENTS(dip, whichfork);
	361	+ mode_t mode = be16_to_cpu(dip->di_mode);
	362	+ uint32_t fork_size = XFS_DFORK_SIZE(dip, mp, whichfork);
	363	+ uint32_t fork_format = XFS_DFORK_FORMAT(dip, whichfork);
384	364
385		- switch (XFS_DFORK_FORMAT(dip, whichfork)) {
386		- case XFS_DINODE_FMT_LOCAL:
387		- /*
388		- * no local regular files yet
389		- */
390		- if (whichfork == XFS_DATA_FORK) {
391		- if (S_ISREG(be16_to_cpu(dip->di_mode)))
392		- return __this_address;
393		- if (be64_to_cpu(dip->di_size) >
394		- XFS_DFORK_SIZE(dip, mp, whichfork))
	365	+ /*
	366	+ * For fork types that can contain local data, check that the fork
	367	+ * format matches the size of local data contained within the fork.
	368	+ *
	369	+ * For all types, check that when the size says the should be in extent
	370	+ * or btree format, the inode isn't claiming it is in local format.
	371	+ */
	372	+ if (whichfork == XFS_DATA_FORK) {
	373	+ if (S_ISDIR(mode) \|\| S_ISLNK(mode)) {
	374	+ if (be64_to_cpu(dip->di_size) <= fork_size &&
	375	+ fork_format != XFS_DINODE_FMT_LOCAL)
395	376	return __this_address;
396	377	}
	378	+
	379	+ if (be64_to_cpu(dip->di_size) > fork_size &&
	380	+ fork_format == XFS_DINODE_FMT_LOCAL)
	381	+ return __this_address;
	382	+ }
	383	+
	384	+ switch (fork_format) {
	385	+ case XFS_DINODE_FMT_LOCAL:
	386	+ /*
	387	+ * No local regular files yet.
	388	+ */
	389	+ if (S_ISREG(mode) && whichfork == XFS_DATA_FORK)
	390	+ return __this_address;
397	391	if (di_nextents)
398	392	return __this_address;
399	393	break;
..	..	@@ -420,7 +414,7 @@
420	414	struct xfs_dinode *dip,
421	415	struct xfs_mount *mp)
422	416	{
423		- if (!XFS_DFORK_Q(dip))
	417	+ if (!dip->di_forkoff)
424	418	return NULL;
425	419
426	420	switch (dip->di_format) {
..	..	@@ -431,7 +425,7 @@
431	425	case XFS_DINODE_FMT_LOCAL: /* fall through ... */
432	426	case XFS_DINODE_FMT_EXTENTS: /* fall through ... */
433	427	case XFS_DINODE_FMT_BTREE:
434		- if (dip->di_forkoff >= (XFS_LITINO(mp, dip->di_version) >> 3))
	428	+ if (dip->di_forkoff >= (XFS_LITINO(mp) >> 3))
435	429	return __this_address;
436	430	break;
437	431	default:
..	..	@@ -457,7 +451,7 @@
457	451
458	452	/* Verify v3 integrity information first */
459	453	if (dip->di_version >= 3) {
460		- if (!xfs_sb_version_hascrc(&mp->m_sb))
	454	+ if (!xfs_sb_version_has_v3inode(&mp->m_sb))
461	455	return __this_address;
462	456	if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize,
463	457	XFS_DINODE_CRC_OFF))
..	..	@@ -523,7 +517,7 @@
523	517	return __this_address;
524	518	}
525	519
526		- if (XFS_DFORK_Q(dip)) {
	520	+ if (dip->di_forkoff) {
527	521	fa = xfs_dinode_verify_fork(dip, mp, XFS_ATTR_FORK);
528	522	if (fa)
529	523	return fa;
..	..	@@ -580,6 +574,11 @@
580	574	if (fa)
581	575	return fa;
582	576
	577	+ /* bigtime iflag can only happen on bigtime filesystems */
	578	+ if (xfs_dinode_has_bigtime(dip) &&
	579	+ !xfs_sb_version_hasbigtime(&mp->m_sb))
	580	+ return __this_address;
	581	+
583	582	return NULL;
584	583	}
585	584
..	..	@@ -597,127 +596,6 @@
597	596	crc = xfs_start_cksum_update((char *)dip, mp->m_sb.sb_inodesize,
598	597	XFS_DINODE_CRC_OFF);
599	598	dip->di_crc = xfs_end_cksum(crc);
600		-}
601		-
602		-/*
603		- * Read the disk inode attributes into the in-core inode structure.
604		- *
605		- * For version 5 superblocks, if we are initialising a new inode and we are not
606		- * utilising the XFS_MOUNT_IKEEP inode cluster mode, we can simple build the new
607		- * inode core with a random generation number. If we are keeping inodes around,
608		- * we need to read the inode cluster to get the existing generation number off
609		- * disk. Further, if we are using version 4 superblocks (i.e. v1/v2 inode
610		- * format) then log recovery is dependent on the di_flushiter field being
611		- * initialised from the current on-disk value and hence we must also read the
612		- * inode off disk.
613		- */
614		-int
615		-xfs_iread(
616		- xfs_mount_t *mp,
617		- xfs_trans_t *tp,
618		- xfs_inode_t *ip,
619		- uint iget_flags)
620		-{
621		- xfs_buf_t *bp;
622		- xfs_dinode_t *dip;
623		- xfs_failaddr_t fa;
624		- int error;
625		-
626		- /*
627		- * Fill in the location information in the in-core inode.
628		- */
629		- error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, iget_flags);
630		- if (error)
631		- return error;
632		-
633		- /* shortcut IO on inode allocation if possible */
634		- if ((iget_flags & XFS_IGET_CREATE) &&
635		- xfs_sb_version_hascrc(&mp->m_sb) &&
636		- !(mp->m_flags & XFS_MOUNT_IKEEP)) {
637		- /* initialise the on-disk inode core */
638		- memset(&ip->i_d, 0, sizeof(ip->i_d));
639		- VFS_I(ip)->i_generation = prandom_u32();
640		- ip->i_d.di_version = 3;
641		- return 0;
642		- }
643		-
644		- /*
645		- * Get pointers to the on-disk inode and the buffer containing it.
646		- */
647		- error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &bp, 0, iget_flags);
648		- if (error)
649		- return error;
650		-
651		- /* even unallocated inodes are verified */
652		- fa = xfs_dinode_verify(mp, ip->i_ino, dip);
653		- if (fa) {
654		- xfs_inode_verifier_error(ip, -EFSCORRUPTED, "dinode", dip,
655		- sizeof(*dip), fa);
656		- error = -EFSCORRUPTED;
657		- goto out_brelse;
658		- }
659		-
660		- /*
661		- * If the on-disk inode is already linked to a directory
662		- * entry, copy all of the inode into the in-core inode.
663		- * xfs_iformat_fork() handles copying in the inode format
664		- * specific information.
665		- * Otherwise, just get the truly permanent information.
666		- */
667		- if (dip->di_mode) {
668		- xfs_inode_from_disk(ip, dip);
669		- error = xfs_iformat_fork(ip, dip);
670		- if (error) {
671		-#ifdef DEBUG
672		- xfs_alert(mp, "%s: xfs_iformat() returned error %d",
673		- __func__, error);
674		-#endif /* DEBUG */
675		- goto out_brelse;
676		- }
677		- } else {
678		- /*
679		- * Partial initialisation of the in-core inode. Just the bits
680		- * that xfs_ialloc won't overwrite or relies on being correct.
681		- */
682		- ip->i_d.di_version = dip->di_version;
683		- VFS_I(ip)->i_generation = be32_to_cpu(dip->di_gen);
684		- ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
685		-
686		- /*
687		- * Make sure to pull in the mode here as well in
688		- * case the inode is released without being used.
689		- * This ensures that xfs_inactive() will see that
690		- * the inode is already free and not try to mess
691		- * with the uninitialized part of it.
692		- */
693		- VFS_I(ip)->i_mode = 0;
694		- }
695		-
696		- ASSERT(ip->i_d.di_version >= 2);
697		- ip->i_delayed_blks = 0;
698		-
699		- /*
700		- * Mark the buffer containing the inode as something to keep
701		- * around for a while. This helps to keep recently accessed
702		- * meta-data in-core longer.
703		- */
704		- xfs_buf_set_ref(bp, XFS_INO_REF);
705		-
706		- /*
707		- * Use xfs_trans_brelse() to release the buffer containing the on-disk
708		- * inode, because it was acquired with xfs_trans_read_buf() in
709		- * xfs_imap_to_bp() above. If tp is NULL, this is just a normal
710		- * brelse(). If we're within a transaction, then xfs_trans_brelse()
711		- * will only release the buffer if it is not dirty within the
712		- * transaction. It will be OK to release the buffer in this case,
713		- * because inodes on disk are never destroyed and we will be locking the
714		- * new in-core inode before putting it in the cache where other
715		- * processes can find it. Thus we don't have to worry about the inode
716		- * being changed just because we released the buffer.
717		- */
718		- out_brelse:
719		- xfs_trans_brelse(tp, bp);
720		- return error;
721	599	}
722	600
723	601	/*