xref: /openbmc/linux/fs/xfs/xfs_inode_item.c (revision 4f205687)
1 /*
2  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_format.h"
21 #include "xfs_log_format.h"
22 #include "xfs_trans_resv.h"
23 #include "xfs_mount.h"
24 #include "xfs_inode.h"
25 #include "xfs_trans.h"
26 #include "xfs_inode_item.h"
27 #include "xfs_error.h"
28 #include "xfs_trace.h"
29 #include "xfs_trans_priv.h"
30 #include "xfs_log.h"
31 
32 
33 kmem_zone_t	*xfs_ili_zone;		/* inode log item zone */
34 
35 static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
36 {
37 	return container_of(lip, struct xfs_inode_log_item, ili_item);
38 }
39 
40 STATIC void
41 xfs_inode_item_data_fork_size(
42 	struct xfs_inode_log_item *iip,
43 	int			*nvecs,
44 	int			*nbytes)
45 {
46 	struct xfs_inode	*ip = iip->ili_inode;
47 
48 	switch (ip->i_d.di_format) {
49 	case XFS_DINODE_FMT_EXTENTS:
50 		if ((iip->ili_fields & XFS_ILOG_DEXT) &&
51 		    ip->i_d.di_nextents > 0 &&
52 		    ip->i_df.if_bytes > 0) {
53 			/* worst case, doesn't subtract delalloc extents */
54 			*nbytes += XFS_IFORK_DSIZE(ip);
55 			*nvecs += 1;
56 		}
57 		break;
58 	case XFS_DINODE_FMT_BTREE:
59 		if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
60 		    ip->i_df.if_broot_bytes > 0) {
61 			*nbytes += ip->i_df.if_broot_bytes;
62 			*nvecs += 1;
63 		}
64 		break;
65 	case XFS_DINODE_FMT_LOCAL:
66 		if ((iip->ili_fields & XFS_ILOG_DDATA) &&
67 		    ip->i_df.if_bytes > 0) {
68 			*nbytes += roundup(ip->i_df.if_bytes, 4);
69 			*nvecs += 1;
70 		}
71 		break;
72 
73 	case XFS_DINODE_FMT_DEV:
74 	case XFS_DINODE_FMT_UUID:
75 		break;
76 	default:
77 		ASSERT(0);
78 		break;
79 	}
80 }
81 
82 STATIC void
83 xfs_inode_item_attr_fork_size(
84 	struct xfs_inode_log_item *iip,
85 	int			*nvecs,
86 	int			*nbytes)
87 {
88 	struct xfs_inode	*ip = iip->ili_inode;
89 
90 	switch (ip->i_d.di_aformat) {
91 	case XFS_DINODE_FMT_EXTENTS:
92 		if ((iip->ili_fields & XFS_ILOG_AEXT) &&
93 		    ip->i_d.di_anextents > 0 &&
94 		    ip->i_afp->if_bytes > 0) {
95 			/* worst case, doesn't subtract unused space */
96 			*nbytes += XFS_IFORK_ASIZE(ip);
97 			*nvecs += 1;
98 		}
99 		break;
100 	case XFS_DINODE_FMT_BTREE:
101 		if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
102 		    ip->i_afp->if_broot_bytes > 0) {
103 			*nbytes += ip->i_afp->if_broot_bytes;
104 			*nvecs += 1;
105 		}
106 		break;
107 	case XFS_DINODE_FMT_LOCAL:
108 		if ((iip->ili_fields & XFS_ILOG_ADATA) &&
109 		    ip->i_afp->if_bytes > 0) {
110 			*nbytes += roundup(ip->i_afp->if_bytes, 4);
111 			*nvecs += 1;
112 		}
113 		break;
114 	default:
115 		ASSERT(0);
116 		break;
117 	}
118 }
119 
120 /*
121  * This returns the number of iovecs needed to log the given inode item.
122  *
123  * We need one iovec for the inode log format structure, one for the
124  * inode core, and possibly one for the inode data/extents/b-tree root
125  * and one for the inode attribute data/extents/b-tree root.
126  */
127 STATIC void
128 xfs_inode_item_size(
129 	struct xfs_log_item	*lip,
130 	int			*nvecs,
131 	int			*nbytes)
132 {
133 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
134 	struct xfs_inode	*ip = iip->ili_inode;
135 
136 	*nvecs += 2;
137 	*nbytes += sizeof(struct xfs_inode_log_format) +
138 		   xfs_log_dinode_size(ip->i_d.di_version);
139 
140 	xfs_inode_item_data_fork_size(iip, nvecs, nbytes);
141 	if (XFS_IFORK_Q(ip))
142 		xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
143 }
144 
145 STATIC void
146 xfs_inode_item_format_data_fork(
147 	struct xfs_inode_log_item *iip,
148 	struct xfs_inode_log_format *ilf,
149 	struct xfs_log_vec	*lv,
150 	struct xfs_log_iovec	**vecp)
151 {
152 	struct xfs_inode	*ip = iip->ili_inode;
153 	size_t			data_bytes;
154 
155 	switch (ip->i_d.di_format) {
156 	case XFS_DINODE_FMT_EXTENTS:
157 		iip->ili_fields &=
158 			~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
159 			  XFS_ILOG_DEV | XFS_ILOG_UUID);
160 
161 		if ((iip->ili_fields & XFS_ILOG_DEXT) &&
162 		    ip->i_d.di_nextents > 0 &&
163 		    ip->i_df.if_bytes > 0) {
164 			struct xfs_bmbt_rec *p;
165 
166 			ASSERT(ip->i_df.if_u1.if_extents != NULL);
167 			ASSERT(ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) > 0);
168 
169 			p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
170 			data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
171 			xlog_finish_iovec(lv, *vecp, data_bytes);
172 
173 			ASSERT(data_bytes <= ip->i_df.if_bytes);
174 
175 			ilf->ilf_dsize = data_bytes;
176 			ilf->ilf_size++;
177 		} else {
178 			iip->ili_fields &= ~XFS_ILOG_DEXT;
179 		}
180 		break;
181 	case XFS_DINODE_FMT_BTREE:
182 		iip->ili_fields &=
183 			~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
184 			  XFS_ILOG_DEV | XFS_ILOG_UUID);
185 
186 		if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
187 		    ip->i_df.if_broot_bytes > 0) {
188 			ASSERT(ip->i_df.if_broot != NULL);
189 			xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
190 					ip->i_df.if_broot,
191 					ip->i_df.if_broot_bytes);
192 			ilf->ilf_dsize = ip->i_df.if_broot_bytes;
193 			ilf->ilf_size++;
194 		} else {
195 			ASSERT(!(iip->ili_fields &
196 				 XFS_ILOG_DBROOT));
197 			iip->ili_fields &= ~XFS_ILOG_DBROOT;
198 		}
199 		break;
200 	case XFS_DINODE_FMT_LOCAL:
201 		iip->ili_fields &=
202 			~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
203 			  XFS_ILOG_DEV | XFS_ILOG_UUID);
204 		if ((iip->ili_fields & XFS_ILOG_DDATA) &&
205 		    ip->i_df.if_bytes > 0) {
206 			/*
207 			 * Round i_bytes up to a word boundary.
208 			 * The underlying memory is guaranteed to
209 			 * to be there by xfs_idata_realloc().
210 			 */
211 			data_bytes = roundup(ip->i_df.if_bytes, 4);
212 			ASSERT(ip->i_df.if_real_bytes == 0 ||
213 			       ip->i_df.if_real_bytes >= data_bytes);
214 			ASSERT(ip->i_df.if_u1.if_data != NULL);
215 			ASSERT(ip->i_d.di_size > 0);
216 			xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
217 					ip->i_df.if_u1.if_data, data_bytes);
218 			ilf->ilf_dsize = (unsigned)data_bytes;
219 			ilf->ilf_size++;
220 		} else {
221 			iip->ili_fields &= ~XFS_ILOG_DDATA;
222 		}
223 		break;
224 	case XFS_DINODE_FMT_DEV:
225 		iip->ili_fields &=
226 			~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
227 			  XFS_ILOG_DEXT | XFS_ILOG_UUID);
228 		if (iip->ili_fields & XFS_ILOG_DEV)
229 			ilf->ilf_u.ilfu_rdev = ip->i_df.if_u2.if_rdev;
230 		break;
231 	case XFS_DINODE_FMT_UUID:
232 		iip->ili_fields &=
233 			~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
234 			  XFS_ILOG_DEXT | XFS_ILOG_DEV);
235 		if (iip->ili_fields & XFS_ILOG_UUID)
236 			ilf->ilf_u.ilfu_uuid = ip->i_df.if_u2.if_uuid;
237 		break;
238 	default:
239 		ASSERT(0);
240 		break;
241 	}
242 }
243 
244 STATIC void
245 xfs_inode_item_format_attr_fork(
246 	struct xfs_inode_log_item *iip,
247 	struct xfs_inode_log_format *ilf,
248 	struct xfs_log_vec	*lv,
249 	struct xfs_log_iovec	**vecp)
250 {
251 	struct xfs_inode	*ip = iip->ili_inode;
252 	size_t			data_bytes;
253 
254 	switch (ip->i_d.di_aformat) {
255 	case XFS_DINODE_FMT_EXTENTS:
256 		iip->ili_fields &=
257 			~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
258 
259 		if ((iip->ili_fields & XFS_ILOG_AEXT) &&
260 		    ip->i_d.di_anextents > 0 &&
261 		    ip->i_afp->if_bytes > 0) {
262 			struct xfs_bmbt_rec *p;
263 
264 			ASSERT(ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) ==
265 				ip->i_d.di_anextents);
266 			ASSERT(ip->i_afp->if_u1.if_extents != NULL);
267 
268 			p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
269 			data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
270 			xlog_finish_iovec(lv, *vecp, data_bytes);
271 
272 			ilf->ilf_asize = data_bytes;
273 			ilf->ilf_size++;
274 		} else {
275 			iip->ili_fields &= ~XFS_ILOG_AEXT;
276 		}
277 		break;
278 	case XFS_DINODE_FMT_BTREE:
279 		iip->ili_fields &=
280 			~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
281 
282 		if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
283 		    ip->i_afp->if_broot_bytes > 0) {
284 			ASSERT(ip->i_afp->if_broot != NULL);
285 
286 			xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
287 					ip->i_afp->if_broot,
288 					ip->i_afp->if_broot_bytes);
289 			ilf->ilf_asize = ip->i_afp->if_broot_bytes;
290 			ilf->ilf_size++;
291 		} else {
292 			iip->ili_fields &= ~XFS_ILOG_ABROOT;
293 		}
294 		break;
295 	case XFS_DINODE_FMT_LOCAL:
296 		iip->ili_fields &=
297 			~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
298 
299 		if ((iip->ili_fields & XFS_ILOG_ADATA) &&
300 		    ip->i_afp->if_bytes > 0) {
301 			/*
302 			 * Round i_bytes up to a word boundary.
303 			 * The underlying memory is guaranteed to
304 			 * to be there by xfs_idata_realloc().
305 			 */
306 			data_bytes = roundup(ip->i_afp->if_bytes, 4);
307 			ASSERT(ip->i_afp->if_real_bytes == 0 ||
308 			       ip->i_afp->if_real_bytes >= data_bytes);
309 			ASSERT(ip->i_afp->if_u1.if_data != NULL);
310 			xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
311 					ip->i_afp->if_u1.if_data,
312 					data_bytes);
313 			ilf->ilf_asize = (unsigned)data_bytes;
314 			ilf->ilf_size++;
315 		} else {
316 			iip->ili_fields &= ~XFS_ILOG_ADATA;
317 		}
318 		break;
319 	default:
320 		ASSERT(0);
321 		break;
322 	}
323 }
324 
325 static void
326 xfs_inode_to_log_dinode(
327 	struct xfs_inode	*ip,
328 	struct xfs_log_dinode	*to,
329 	xfs_lsn_t		lsn)
330 {
331 	struct xfs_icdinode	*from = &ip->i_d;
332 	struct inode		*inode = VFS_I(ip);
333 
334 	to->di_magic = XFS_DINODE_MAGIC;
335 
336 	to->di_version = from->di_version;
337 	to->di_format = from->di_format;
338 	to->di_uid = from->di_uid;
339 	to->di_gid = from->di_gid;
340 	to->di_projid_lo = from->di_projid_lo;
341 	to->di_projid_hi = from->di_projid_hi;
342 
343 	memset(to->di_pad, 0, sizeof(to->di_pad));
344 	memset(to->di_pad3, 0, sizeof(to->di_pad3));
345 	to->di_atime.t_sec = inode->i_atime.tv_sec;
346 	to->di_atime.t_nsec = inode->i_atime.tv_nsec;
347 	to->di_mtime.t_sec = inode->i_mtime.tv_sec;
348 	to->di_mtime.t_nsec = inode->i_mtime.tv_nsec;
349 	to->di_ctime.t_sec = inode->i_ctime.tv_sec;
350 	to->di_ctime.t_nsec = inode->i_ctime.tv_nsec;
351 	to->di_nlink = inode->i_nlink;
352 	to->di_gen = inode->i_generation;
353 	to->di_mode = inode->i_mode;
354 
355 	to->di_size = from->di_size;
356 	to->di_nblocks = from->di_nblocks;
357 	to->di_extsize = from->di_extsize;
358 	to->di_nextents = from->di_nextents;
359 	to->di_anextents = from->di_anextents;
360 	to->di_forkoff = from->di_forkoff;
361 	to->di_aformat = from->di_aformat;
362 	to->di_dmevmask = from->di_dmevmask;
363 	to->di_dmstate = from->di_dmstate;
364 	to->di_flags = from->di_flags;
365 
366 	if (from->di_version == 3) {
367 		to->di_changecount = inode->i_version;
368 		to->di_crtime.t_sec = from->di_crtime.t_sec;
369 		to->di_crtime.t_nsec = from->di_crtime.t_nsec;
370 		to->di_flags2 = from->di_flags2;
371 
372 		to->di_ino = ip->i_ino;
373 		to->di_lsn = lsn;
374 		memset(to->di_pad2, 0, sizeof(to->di_pad2));
375 		uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
376 		to->di_flushiter = 0;
377 	} else {
378 		to->di_flushiter = from->di_flushiter;
379 	}
380 }
381 
382 /*
383  * Format the inode core. Current timestamp data is only in the VFS inode
384  * fields, so we need to grab them from there. Hence rather than just copying
385  * the XFS inode core structure, format the fields directly into the iovec.
386  */
387 static void
388 xfs_inode_item_format_core(
389 	struct xfs_inode	*ip,
390 	struct xfs_log_vec	*lv,
391 	struct xfs_log_iovec	**vecp)
392 {
393 	struct xfs_log_dinode	*dic;
394 
395 	dic = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_ICORE);
396 	xfs_inode_to_log_dinode(ip, dic, ip->i_itemp->ili_item.li_lsn);
397 	xlog_finish_iovec(lv, *vecp, xfs_log_dinode_size(ip->i_d.di_version));
398 }
399 
400 /*
401  * This is called to fill in the vector of log iovecs for the given inode
402  * log item.  It fills the first item with an inode log format structure,
403  * the second with the on-disk inode structure, and a possible third and/or
404  * fourth with the inode data/extents/b-tree root and inode attributes
405  * data/extents/b-tree root.
406  */
407 STATIC void
408 xfs_inode_item_format(
409 	struct xfs_log_item	*lip,
410 	struct xfs_log_vec	*lv)
411 {
412 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
413 	struct xfs_inode	*ip = iip->ili_inode;
414 	struct xfs_inode_log_format *ilf;
415 	struct xfs_log_iovec	*vecp = NULL;
416 
417 	ASSERT(ip->i_d.di_version > 1);
418 
419 	ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
420 	ilf->ilf_type = XFS_LI_INODE;
421 	ilf->ilf_ino = ip->i_ino;
422 	ilf->ilf_blkno = ip->i_imap.im_blkno;
423 	ilf->ilf_len = ip->i_imap.im_len;
424 	ilf->ilf_boffset = ip->i_imap.im_boffset;
425 	ilf->ilf_fields = XFS_ILOG_CORE;
426 	ilf->ilf_size = 2; /* format + core */
427 	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_inode_log_format));
428 
429 	xfs_inode_item_format_core(ip, lv, &vecp);
430 	xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
431 	if (XFS_IFORK_Q(ip)) {
432 		xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
433 	} else {
434 		iip->ili_fields &=
435 			~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
436 	}
437 
438 	/* update the format with the exact fields we actually logged */
439 	ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
440 }
441 
442 /*
443  * This is called to pin the inode associated with the inode log
444  * item in memory so it cannot be written out.
445  */
446 STATIC void
447 xfs_inode_item_pin(
448 	struct xfs_log_item	*lip)
449 {
450 	struct xfs_inode	*ip = INODE_ITEM(lip)->ili_inode;
451 
452 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
453 
454 	trace_xfs_inode_pin(ip, _RET_IP_);
455 	atomic_inc(&ip->i_pincount);
456 }
457 
458 
459 /*
460  * This is called to unpin the inode associated with the inode log
461  * item which was previously pinned with a call to xfs_inode_item_pin().
462  *
463  * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
464  */
465 STATIC void
466 xfs_inode_item_unpin(
467 	struct xfs_log_item	*lip,
468 	int			remove)
469 {
470 	struct xfs_inode	*ip = INODE_ITEM(lip)->ili_inode;
471 
472 	trace_xfs_inode_unpin(ip, _RET_IP_);
473 	ASSERT(atomic_read(&ip->i_pincount) > 0);
474 	if (atomic_dec_and_test(&ip->i_pincount))
475 		wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
476 }
477 
478 STATIC uint
479 xfs_inode_item_push(
480 	struct xfs_log_item	*lip,
481 	struct list_head	*buffer_list)
482 		__releases(&lip->li_ailp->xa_lock)
483 		__acquires(&lip->li_ailp->xa_lock)
484 {
485 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
486 	struct xfs_inode	*ip = iip->ili_inode;
487 	struct xfs_buf		*bp = NULL;
488 	uint			rval = XFS_ITEM_SUCCESS;
489 	int			error;
490 
491 	if (xfs_ipincount(ip) > 0)
492 		return XFS_ITEM_PINNED;
493 
494 	if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
495 		return XFS_ITEM_LOCKED;
496 
497 	/*
498 	 * Re-check the pincount now that we stabilized the value by
499 	 * taking the ilock.
500 	 */
501 	if (xfs_ipincount(ip) > 0) {
502 		rval = XFS_ITEM_PINNED;
503 		goto out_unlock;
504 	}
505 
506 	/*
507 	 * Stale inode items should force out the iclog.
508 	 */
509 	if (ip->i_flags & XFS_ISTALE) {
510 		rval = XFS_ITEM_PINNED;
511 		goto out_unlock;
512 	}
513 
514 	/*
515 	 * Someone else is already flushing the inode.  Nothing we can do
516 	 * here but wait for the flush to finish and remove the item from
517 	 * the AIL.
518 	 */
519 	if (!xfs_iflock_nowait(ip)) {
520 		rval = XFS_ITEM_FLUSHING;
521 		goto out_unlock;
522 	}
523 
524 	ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
525 	ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
526 
527 	spin_unlock(&lip->li_ailp->xa_lock);
528 
529 	error = xfs_iflush(ip, &bp);
530 	if (!error) {
531 		if (!xfs_buf_delwri_queue(bp, buffer_list))
532 			rval = XFS_ITEM_FLUSHING;
533 		xfs_buf_relse(bp);
534 	}
535 
536 	spin_lock(&lip->li_ailp->xa_lock);
537 out_unlock:
538 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
539 	return rval;
540 }
541 
542 /*
543  * Unlock the inode associated with the inode log item.
544  * Clear the fields of the inode and inode log item that
545  * are specific to the current transaction.  If the
546  * hold flags is set, do not unlock the inode.
547  */
548 STATIC void
549 xfs_inode_item_unlock(
550 	struct xfs_log_item	*lip)
551 {
552 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
553 	struct xfs_inode	*ip = iip->ili_inode;
554 	unsigned short		lock_flags;
555 
556 	ASSERT(ip->i_itemp != NULL);
557 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
558 
559 	lock_flags = iip->ili_lock_flags;
560 	iip->ili_lock_flags = 0;
561 	if (lock_flags)
562 		xfs_iunlock(ip, lock_flags);
563 }
564 
565 /*
566  * This is called to find out where the oldest active copy of the inode log
567  * item in the on disk log resides now that the last log write of it completed
568  * at the given lsn.  Since we always re-log all dirty data in an inode, the
569  * latest copy in the on disk log is the only one that matters.  Therefore,
570  * simply return the given lsn.
571  *
572  * If the inode has been marked stale because the cluster is being freed, we
573  * don't want to (re-)insert this inode into the AIL. There is a race condition
574  * where the cluster buffer may be unpinned before the inode is inserted into
575  * the AIL during transaction committed processing. If the buffer is unpinned
576  * before the inode item has been committed and inserted, then it is possible
577  * for the buffer to be written and IO completes before the inode is inserted
578  * into the AIL. In that case, we'd be inserting a clean, stale inode into the
579  * AIL which will never get removed. It will, however, get reclaimed which
580  * triggers an assert in xfs_inode_free() complaining about freein an inode
581  * still in the AIL.
582  *
583  * To avoid this, just unpin the inode directly and return a LSN of -1 so the
584  * transaction committed code knows that it does not need to do any further
585  * processing on the item.
586  */
587 STATIC xfs_lsn_t
588 xfs_inode_item_committed(
589 	struct xfs_log_item	*lip,
590 	xfs_lsn_t		lsn)
591 {
592 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
593 	struct xfs_inode	*ip = iip->ili_inode;
594 
595 	if (xfs_iflags_test(ip, XFS_ISTALE)) {
596 		xfs_inode_item_unpin(lip, 0);
597 		return -1;
598 	}
599 	return lsn;
600 }
601 
602 /*
603  * XXX rcc - this one really has to do something.  Probably needs
604  * to stamp in a new field in the incore inode.
605  */
606 STATIC void
607 xfs_inode_item_committing(
608 	struct xfs_log_item	*lip,
609 	xfs_lsn_t		lsn)
610 {
611 	INODE_ITEM(lip)->ili_last_lsn = lsn;
612 }
613 
614 /*
615  * This is the ops vector shared by all buf log items.
616  */
617 static const struct xfs_item_ops xfs_inode_item_ops = {
618 	.iop_size	= xfs_inode_item_size,
619 	.iop_format	= xfs_inode_item_format,
620 	.iop_pin	= xfs_inode_item_pin,
621 	.iop_unpin	= xfs_inode_item_unpin,
622 	.iop_unlock	= xfs_inode_item_unlock,
623 	.iop_committed	= xfs_inode_item_committed,
624 	.iop_push	= xfs_inode_item_push,
625 	.iop_committing = xfs_inode_item_committing
626 };
627 
628 
629 /*
630  * Initialize the inode log item for a newly allocated (in-core) inode.
631  */
632 void
633 xfs_inode_item_init(
634 	struct xfs_inode	*ip,
635 	struct xfs_mount	*mp)
636 {
637 	struct xfs_inode_log_item *iip;
638 
639 	ASSERT(ip->i_itemp == NULL);
640 	iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP);
641 
642 	iip->ili_inode = ip;
643 	xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
644 						&xfs_inode_item_ops);
645 }
646 
647 /*
648  * Free the inode log item and any memory hanging off of it.
649  */
650 void
651 xfs_inode_item_destroy(
652 	xfs_inode_t	*ip)
653 {
654 	kmem_zone_free(xfs_ili_zone, ip->i_itemp);
655 }
656 
657 
658 /*
659  * This is the inode flushing I/O completion routine.  It is called
660  * from interrupt level when the buffer containing the inode is
661  * flushed to disk.  It is responsible for removing the inode item
662  * from the AIL if it has not been re-logged, and unlocking the inode's
663  * flush lock.
664  *
665  * To reduce AIL lock traffic as much as possible, we scan the buffer log item
666  * list for other inodes that will run this function. We remove them from the
667  * buffer list so we can process all the inode IO completions in one AIL lock
668  * traversal.
669  */
670 void
671 xfs_iflush_done(
672 	struct xfs_buf		*bp,
673 	struct xfs_log_item	*lip)
674 {
675 	struct xfs_inode_log_item *iip;
676 	struct xfs_log_item	*blip;
677 	struct xfs_log_item	*next;
678 	struct xfs_log_item	*prev;
679 	struct xfs_ail		*ailp = lip->li_ailp;
680 	int			need_ail = 0;
681 
682 	/*
683 	 * Scan the buffer IO completions for other inodes being completed and
684 	 * attach them to the current inode log item.
685 	 */
686 	blip = bp->b_fspriv;
687 	prev = NULL;
688 	while (blip != NULL) {
689 		if (blip->li_cb != xfs_iflush_done) {
690 			prev = blip;
691 			blip = blip->li_bio_list;
692 			continue;
693 		}
694 
695 		/* remove from list */
696 		next = blip->li_bio_list;
697 		if (!prev) {
698 			bp->b_fspriv = next;
699 		} else {
700 			prev->li_bio_list = next;
701 		}
702 
703 		/* add to current list */
704 		blip->li_bio_list = lip->li_bio_list;
705 		lip->li_bio_list = blip;
706 
707 		/*
708 		 * while we have the item, do the unlocked check for needing
709 		 * the AIL lock.
710 		 */
711 		iip = INODE_ITEM(blip);
712 		if (iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn)
713 			need_ail++;
714 
715 		blip = next;
716 	}
717 
718 	/* make sure we capture the state of the initial inode. */
719 	iip = INODE_ITEM(lip);
720 	if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn)
721 		need_ail++;
722 
723 	/*
724 	 * We only want to pull the item from the AIL if it is
725 	 * actually there and its location in the log has not
726 	 * changed since we started the flush.  Thus, we only bother
727 	 * if the ili_logged flag is set and the inode's lsn has not
728 	 * changed.  First we check the lsn outside
729 	 * the lock since it's cheaper, and then we recheck while
730 	 * holding the lock before removing the inode from the AIL.
731 	 */
732 	if (need_ail) {
733 		struct xfs_log_item *log_items[need_ail];
734 		int i = 0;
735 		spin_lock(&ailp->xa_lock);
736 		for (blip = lip; blip; blip = blip->li_bio_list) {
737 			iip = INODE_ITEM(blip);
738 			if (iip->ili_logged &&
739 			    blip->li_lsn == iip->ili_flush_lsn) {
740 				log_items[i++] = blip;
741 			}
742 			ASSERT(i <= need_ail);
743 		}
744 		/* xfs_trans_ail_delete_bulk() drops the AIL lock. */
745 		xfs_trans_ail_delete_bulk(ailp, log_items, i,
746 					  SHUTDOWN_CORRUPT_INCORE);
747 	}
748 
749 
750 	/*
751 	 * clean up and unlock the flush lock now we are done. We can clear the
752 	 * ili_last_fields bits now that we know that the data corresponding to
753 	 * them is safely on disk.
754 	 */
755 	for (blip = lip; blip; blip = next) {
756 		next = blip->li_bio_list;
757 		blip->li_bio_list = NULL;
758 
759 		iip = INODE_ITEM(blip);
760 		iip->ili_logged = 0;
761 		iip->ili_last_fields = 0;
762 		xfs_ifunlock(iip->ili_inode);
763 	}
764 }
765 
766 /*
767  * This is the inode flushing abort routine.  It is called from xfs_iflush when
768  * the filesystem is shutting down to clean up the inode state.  It is
769  * responsible for removing the inode item from the AIL if it has not been
770  * re-logged, and unlocking the inode's flush lock.
771  */
772 void
773 xfs_iflush_abort(
774 	xfs_inode_t		*ip,
775 	bool			stale)
776 {
777 	xfs_inode_log_item_t	*iip = ip->i_itemp;
778 
779 	if (iip) {
780 		if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
781 			xfs_trans_ail_remove(&iip->ili_item,
782 					     stale ? SHUTDOWN_LOG_IO_ERROR :
783 						     SHUTDOWN_CORRUPT_INCORE);
784 		}
785 		iip->ili_logged = 0;
786 		/*
787 		 * Clear the ili_last_fields bits now that we know that the
788 		 * data corresponding to them is safely on disk.
789 		 */
790 		iip->ili_last_fields = 0;
791 		/*
792 		 * Clear the inode logging fields so no more flushes are
793 		 * attempted.
794 		 */
795 		iip->ili_fields = 0;
796 		iip->ili_fsync_fields = 0;
797 	}
798 	/*
799 	 * Release the inode's flush lock since we're done with it.
800 	 */
801 	xfs_ifunlock(ip);
802 }
803 
804 void
805 xfs_istale_done(
806 	struct xfs_buf		*bp,
807 	struct xfs_log_item	*lip)
808 {
809 	xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
810 }
811 
812 /*
813  * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
814  * (which can have different field alignments) to the native version
815  */
816 int
817 xfs_inode_item_format_convert(
818 	xfs_log_iovec_t		*buf,
819 	xfs_inode_log_format_t	*in_f)
820 {
821 	if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
822 		xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
823 
824 		in_f->ilf_type = in_f32->ilf_type;
825 		in_f->ilf_size = in_f32->ilf_size;
826 		in_f->ilf_fields = in_f32->ilf_fields;
827 		in_f->ilf_asize = in_f32->ilf_asize;
828 		in_f->ilf_dsize = in_f32->ilf_dsize;
829 		in_f->ilf_ino = in_f32->ilf_ino;
830 		/* copy biggest field of ilf_u */
831 		memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
832 		       in_f32->ilf_u.ilfu_uuid.__u_bits,
833 		       sizeof(uuid_t));
834 		in_f->ilf_blkno = in_f32->ilf_blkno;
835 		in_f->ilf_len = in_f32->ilf_len;
836 		in_f->ilf_boffset = in_f32->ilf_boffset;
837 		return 0;
838 	} else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
839 		xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
840 
841 		in_f->ilf_type = in_f64->ilf_type;
842 		in_f->ilf_size = in_f64->ilf_size;
843 		in_f->ilf_fields = in_f64->ilf_fields;
844 		in_f->ilf_asize = in_f64->ilf_asize;
845 		in_f->ilf_dsize = in_f64->ilf_dsize;
846 		in_f->ilf_ino = in_f64->ilf_ino;
847 		/* copy biggest field of ilf_u */
848 		memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
849 		       in_f64->ilf_u.ilfu_uuid.__u_bits,
850 		       sizeof(uuid_t));
851 		in_f->ilf_blkno = in_f64->ilf_blkno;
852 		in_f->ilf_len = in_f64->ilf_len;
853 		in_f->ilf_boffset = in_f64->ilf_boffset;
854 		return 0;
855 	}
856 	return -EFSCORRUPTED;
857 }
858