• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
INODE_ITEM(struct xfs_log_item * lip)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
xfs_inode_item_data_fork_size(struct xfs_inode_log_item * iip,int * nvecs,int * nbytes)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
xfs_inode_item_attr_fork_size(struct xfs_inode_log_item * iip,int * nvecs,int * nbytes)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
xfs_inode_item_size(struct xfs_log_item * lip,int * nvecs,int * nbytes)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_icdinode_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
xfs_inode_item_format_data_fork(struct xfs_inode_log_item * iip,struct xfs_inode_log_format * ilf,struct xfs_log_vec * lv,struct xfs_log_iovec ** vecp)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
xfs_inode_item_format_attr_fork(struct xfs_inode_log_item * iip,struct xfs_inode_log_format * ilf,struct xfs_log_vec * lv,struct xfs_log_iovec ** vecp)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 /*
326  * This is called to fill in the vector of log iovecs for the given inode
327  * log item.  It fills the first item with an inode log format structure,
328  * the second with the on-disk inode structure, and a possible third and/or
329  * fourth with the inode data/extents/b-tree root and inode attributes
330  * data/extents/b-tree root.
331  */
332 STATIC void
xfs_inode_item_format(struct xfs_log_item * lip,struct xfs_log_vec * lv)333 xfs_inode_item_format(
334 	struct xfs_log_item	*lip,
335 	struct xfs_log_vec	*lv)
336 {
337 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
338 	struct xfs_inode	*ip = iip->ili_inode;
339 	struct xfs_inode_log_format *ilf;
340 	struct xfs_log_iovec	*vecp = NULL;
341 
342 	ASSERT(ip->i_d.di_version > 1);
343 
344 	ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
345 	ilf->ilf_type = XFS_LI_INODE;
346 	ilf->ilf_ino = ip->i_ino;
347 	ilf->ilf_blkno = ip->i_imap.im_blkno;
348 	ilf->ilf_len = ip->i_imap.im_len;
349 	ilf->ilf_boffset = ip->i_imap.im_boffset;
350 	ilf->ilf_fields = XFS_ILOG_CORE;
351 	ilf->ilf_size = 2; /* format + core */
352 	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_inode_log_format));
353 
354 	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ICORE,
355 			&ip->i_d,
356 			xfs_icdinode_size(ip->i_d.di_version));
357 
358 	xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
359 	if (XFS_IFORK_Q(ip)) {
360 		xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
361 	} else {
362 		iip->ili_fields &=
363 			~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
364 	}
365 
366 	/* update the format with the exact fields we actually logged */
367 	ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
368 }
369 
370 /*
371  * This is called to pin the inode associated with the inode log
372  * item in memory so it cannot be written out.
373  */
374 STATIC void
xfs_inode_item_pin(struct xfs_log_item * lip)375 xfs_inode_item_pin(
376 	struct xfs_log_item	*lip)
377 {
378 	struct xfs_inode	*ip = INODE_ITEM(lip)->ili_inode;
379 
380 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
381 
382 	trace_xfs_inode_pin(ip, _RET_IP_);
383 	atomic_inc(&ip->i_pincount);
384 }
385 
386 
387 /*
388  * This is called to unpin the inode associated with the inode log
389  * item which was previously pinned with a call to xfs_inode_item_pin().
390  *
391  * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
392  */
393 STATIC void
xfs_inode_item_unpin(struct xfs_log_item * lip,int remove)394 xfs_inode_item_unpin(
395 	struct xfs_log_item	*lip,
396 	int			remove)
397 {
398 	struct xfs_inode	*ip = INODE_ITEM(lip)->ili_inode;
399 
400 	trace_xfs_inode_unpin(ip, _RET_IP_);
401 	ASSERT(atomic_read(&ip->i_pincount) > 0);
402 	if (atomic_dec_and_test(&ip->i_pincount))
403 		wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
404 }
405 
406 STATIC uint
xfs_inode_item_push(struct xfs_log_item * lip,struct list_head * buffer_list)407 xfs_inode_item_push(
408 	struct xfs_log_item	*lip,
409 	struct list_head	*buffer_list)
410 {
411 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
412 	struct xfs_inode	*ip = iip->ili_inode;
413 	struct xfs_buf		*bp = NULL;
414 	uint			rval = XFS_ITEM_SUCCESS;
415 	int			error;
416 
417 	if (xfs_ipincount(ip) > 0)
418 		return XFS_ITEM_PINNED;
419 
420 	if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
421 		return XFS_ITEM_LOCKED;
422 
423 	/*
424 	 * Re-check the pincount now that we stabilized the value by
425 	 * taking the ilock.
426 	 */
427 	if (xfs_ipincount(ip) > 0) {
428 		rval = XFS_ITEM_PINNED;
429 		goto out_unlock;
430 	}
431 
432 	/*
433 	 * Stale inode items should force out the iclog.
434 	 */
435 	if (ip->i_flags & XFS_ISTALE) {
436 		rval = XFS_ITEM_PINNED;
437 		goto out_unlock;
438 	}
439 
440 	/*
441 	 * Someone else is already flushing the inode.  Nothing we can do
442 	 * here but wait for the flush to finish and remove the item from
443 	 * the AIL.
444 	 */
445 	if (!xfs_iflock_nowait(ip)) {
446 		rval = XFS_ITEM_FLUSHING;
447 		goto out_unlock;
448 	}
449 
450 	ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
451 	ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
452 
453 	spin_unlock(&lip->li_ailp->xa_lock);
454 
455 	error = xfs_iflush(ip, &bp);
456 	if (!error) {
457 		if (!xfs_buf_delwri_queue(bp, buffer_list))
458 			rval = XFS_ITEM_FLUSHING;
459 		xfs_buf_relse(bp);
460 	}
461 
462 	spin_lock(&lip->li_ailp->xa_lock);
463 out_unlock:
464 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
465 	return rval;
466 }
467 
468 /*
469  * Unlock the inode associated with the inode log item.
470  * Clear the fields of the inode and inode log item that
471  * are specific to the current transaction.  If the
472  * hold flags is set, do not unlock the inode.
473  */
474 STATIC void
xfs_inode_item_unlock(struct xfs_log_item * lip)475 xfs_inode_item_unlock(
476 	struct xfs_log_item	*lip)
477 {
478 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
479 	struct xfs_inode	*ip = iip->ili_inode;
480 	unsigned short		lock_flags;
481 
482 	ASSERT(ip->i_itemp != NULL);
483 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
484 
485 	lock_flags = iip->ili_lock_flags;
486 	iip->ili_lock_flags = 0;
487 	if (lock_flags)
488 		xfs_iunlock(ip, lock_flags);
489 }
490 
491 /*
492  * This is called to find out where the oldest active copy of the inode log
493  * item in the on disk log resides now that the last log write of it completed
494  * at the given lsn.  Since we always re-log all dirty data in an inode, the
495  * latest copy in the on disk log is the only one that matters.  Therefore,
496  * simply return the given lsn.
497  *
498  * If the inode has been marked stale because the cluster is being freed, we
499  * don't want to (re-)insert this inode into the AIL. There is a race condition
500  * where the cluster buffer may be unpinned before the inode is inserted into
501  * the AIL during transaction committed processing. If the buffer is unpinned
502  * before the inode item has been committed and inserted, then it is possible
503  * for the buffer to be written and IO completes before the inode is inserted
504  * into the AIL. In that case, we'd be inserting a clean, stale inode into the
505  * AIL which will never get removed. It will, however, get reclaimed which
506  * triggers an assert in xfs_inode_free() complaining about freein an inode
507  * still in the AIL.
508  *
509  * To avoid this, just unpin the inode directly and return a LSN of -1 so the
510  * transaction committed code knows that it does not need to do any further
511  * processing on the item.
512  */
513 STATIC xfs_lsn_t
xfs_inode_item_committed(struct xfs_log_item * lip,xfs_lsn_t lsn)514 xfs_inode_item_committed(
515 	struct xfs_log_item	*lip,
516 	xfs_lsn_t		lsn)
517 {
518 	struct xfs_inode_log_item *iip = INODE_ITEM(lip);
519 	struct xfs_inode	*ip = iip->ili_inode;
520 
521 	if (xfs_iflags_test(ip, XFS_ISTALE)) {
522 		xfs_inode_item_unpin(lip, 0);
523 		return -1;
524 	}
525 	return lsn;
526 }
527 
528 /*
529  * XXX rcc - this one really has to do something.  Probably needs
530  * to stamp in a new field in the incore inode.
531  */
532 STATIC void
xfs_inode_item_committing(struct xfs_log_item * lip,xfs_lsn_t lsn)533 xfs_inode_item_committing(
534 	struct xfs_log_item	*lip,
535 	xfs_lsn_t		lsn)
536 {
537 	INODE_ITEM(lip)->ili_last_lsn = lsn;
538 }
539 
540 /*
541  * This is the ops vector shared by all buf log items.
542  */
543 static const struct xfs_item_ops xfs_inode_item_ops = {
544 	.iop_size	= xfs_inode_item_size,
545 	.iop_format	= xfs_inode_item_format,
546 	.iop_pin	= xfs_inode_item_pin,
547 	.iop_unpin	= xfs_inode_item_unpin,
548 	.iop_unlock	= xfs_inode_item_unlock,
549 	.iop_committed	= xfs_inode_item_committed,
550 	.iop_push	= xfs_inode_item_push,
551 	.iop_committing = xfs_inode_item_committing
552 };
553 
554 
555 /*
556  * Initialize the inode log item for a newly allocated (in-core) inode.
557  */
558 void
xfs_inode_item_init(struct xfs_inode * ip,struct xfs_mount * mp)559 xfs_inode_item_init(
560 	struct xfs_inode	*ip,
561 	struct xfs_mount	*mp)
562 {
563 	struct xfs_inode_log_item *iip;
564 
565 	ASSERT(ip->i_itemp == NULL);
566 	iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP);
567 
568 	iip->ili_inode = ip;
569 	xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
570 						&xfs_inode_item_ops);
571 }
572 
573 /*
574  * Free the inode log item and any memory hanging off of it.
575  */
576 void
xfs_inode_item_destroy(xfs_inode_t * ip)577 xfs_inode_item_destroy(
578 	xfs_inode_t	*ip)
579 {
580 	kmem_zone_free(xfs_ili_zone, ip->i_itemp);
581 }
582 
583 
584 /*
585  * This is the inode flushing I/O completion routine.  It is called
586  * from interrupt level when the buffer containing the inode is
587  * flushed to disk.  It is responsible for removing the inode item
588  * from the AIL if it has not been re-logged, and unlocking the inode's
589  * flush lock.
590  *
591  * To reduce AIL lock traffic as much as possible, we scan the buffer log item
592  * list for other inodes that will run this function. We remove them from the
593  * buffer list so we can process all the inode IO completions in one AIL lock
594  * traversal.
595  */
596 void
xfs_iflush_done(struct xfs_buf * bp,struct xfs_log_item * lip)597 xfs_iflush_done(
598 	struct xfs_buf		*bp,
599 	struct xfs_log_item	*lip)
600 {
601 	struct xfs_inode_log_item *iip;
602 	struct xfs_log_item	*blip;
603 	struct xfs_log_item	*next;
604 	struct xfs_log_item	*prev;
605 	struct xfs_ail		*ailp = lip->li_ailp;
606 	int			need_ail = 0;
607 
608 	/*
609 	 * Scan the buffer IO completions for other inodes being completed and
610 	 * attach them to the current inode log item.
611 	 */
612 	blip = bp->b_fspriv;
613 	prev = NULL;
614 	while (blip != NULL) {
615 		if (blip->li_cb != xfs_iflush_done) {
616 			prev = blip;
617 			blip = blip->li_bio_list;
618 			continue;
619 		}
620 
621 		/* remove from list */
622 		next = blip->li_bio_list;
623 		if (!prev) {
624 			bp->b_fspriv = next;
625 		} else {
626 			prev->li_bio_list = next;
627 		}
628 
629 		/* add to current list */
630 		blip->li_bio_list = lip->li_bio_list;
631 		lip->li_bio_list = blip;
632 
633 		/*
634 		 * while we have the item, do the unlocked check for needing
635 		 * the AIL lock.
636 		 */
637 		iip = INODE_ITEM(blip);
638 		if (iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn)
639 			need_ail++;
640 
641 		blip = next;
642 	}
643 
644 	/* make sure we capture the state of the initial inode. */
645 	iip = INODE_ITEM(lip);
646 	if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn)
647 		need_ail++;
648 
649 	/*
650 	 * We only want to pull the item from the AIL if it is
651 	 * actually there and its location in the log has not
652 	 * changed since we started the flush.  Thus, we only bother
653 	 * if the ili_logged flag is set and the inode's lsn has not
654 	 * changed.  First we check the lsn outside
655 	 * the lock since it's cheaper, and then we recheck while
656 	 * holding the lock before removing the inode from the AIL.
657 	 */
658 	if (need_ail) {
659 		struct xfs_log_item *log_items[need_ail];
660 		int i = 0;
661 		spin_lock(&ailp->xa_lock);
662 		for (blip = lip; blip; blip = blip->li_bio_list) {
663 			iip = INODE_ITEM(blip);
664 			if (iip->ili_logged &&
665 			    blip->li_lsn == iip->ili_flush_lsn) {
666 				log_items[i++] = blip;
667 			}
668 			ASSERT(i <= need_ail);
669 		}
670 		/* xfs_trans_ail_delete_bulk() drops the AIL lock. */
671 		xfs_trans_ail_delete_bulk(ailp, log_items, i,
672 					  SHUTDOWN_CORRUPT_INCORE);
673 	}
674 
675 
676 	/*
677 	 * clean up and unlock the flush lock now we are done. We can clear the
678 	 * ili_last_fields bits now that we know that the data corresponding to
679 	 * them is safely on disk.
680 	 */
681 	for (blip = lip; blip; blip = next) {
682 		next = blip->li_bio_list;
683 		blip->li_bio_list = NULL;
684 
685 		iip = INODE_ITEM(blip);
686 		iip->ili_logged = 0;
687 		iip->ili_last_fields = 0;
688 		xfs_ifunlock(iip->ili_inode);
689 	}
690 }
691 
692 /*
693  * This is the inode flushing abort routine.  It is called from xfs_iflush when
694  * the filesystem is shutting down to clean up the inode state.  It is
695  * responsible for removing the inode item from the AIL if it has not been
696  * re-logged, and unlocking the inode's flush lock.
697  */
698 void
xfs_iflush_abort(xfs_inode_t * ip,bool stale)699 xfs_iflush_abort(
700 	xfs_inode_t		*ip,
701 	bool			stale)
702 {
703 	xfs_inode_log_item_t	*iip = ip->i_itemp;
704 
705 	if (iip) {
706 		if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
707 			xfs_trans_ail_remove(&iip->ili_item,
708 					     stale ? SHUTDOWN_LOG_IO_ERROR :
709 						     SHUTDOWN_CORRUPT_INCORE);
710 		}
711 		iip->ili_logged = 0;
712 		/*
713 		 * Clear the ili_last_fields bits now that we know that the
714 		 * data corresponding to them is safely on disk.
715 		 */
716 		iip->ili_last_fields = 0;
717 		/*
718 		 * Clear the inode logging fields so no more flushes are
719 		 * attempted.
720 		 */
721 		iip->ili_fields = 0;
722 		iip->ili_fsync_fields = 0;
723 	}
724 	/*
725 	 * Release the inode's flush lock since we're done with it.
726 	 */
727 	xfs_ifunlock(ip);
728 }
729 
730 void
xfs_istale_done(struct xfs_buf * bp,struct xfs_log_item * lip)731 xfs_istale_done(
732 	struct xfs_buf		*bp,
733 	struct xfs_log_item	*lip)
734 {
735 	xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
736 }
737 
738 /*
739  * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
740  * (which can have different field alignments) to the native version
741  */
742 int
xfs_inode_item_format_convert(xfs_log_iovec_t * buf,xfs_inode_log_format_t * in_f)743 xfs_inode_item_format_convert(
744 	xfs_log_iovec_t		*buf,
745 	xfs_inode_log_format_t	*in_f)
746 {
747 	if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
748 		xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
749 
750 		in_f->ilf_type = in_f32->ilf_type;
751 		in_f->ilf_size = in_f32->ilf_size;
752 		in_f->ilf_fields = in_f32->ilf_fields;
753 		in_f->ilf_asize = in_f32->ilf_asize;
754 		in_f->ilf_dsize = in_f32->ilf_dsize;
755 		in_f->ilf_ino = in_f32->ilf_ino;
756 		/* copy biggest field of ilf_u */
757 		memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
758 		       in_f32->ilf_u.ilfu_uuid.__u_bits,
759 		       sizeof(uuid_t));
760 		in_f->ilf_blkno = in_f32->ilf_blkno;
761 		in_f->ilf_len = in_f32->ilf_len;
762 		in_f->ilf_boffset = in_f32->ilf_boffset;
763 		return 0;
764 	} else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
765 		xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
766 
767 		in_f->ilf_type = in_f64->ilf_type;
768 		in_f->ilf_size = in_f64->ilf_size;
769 		in_f->ilf_fields = in_f64->ilf_fields;
770 		in_f->ilf_asize = in_f64->ilf_asize;
771 		in_f->ilf_dsize = in_f64->ilf_dsize;
772 		in_f->ilf_ino = in_f64->ilf_ino;
773 		/* copy biggest field of ilf_u */
774 		memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
775 		       in_f64->ilf_u.ilfu_uuid.__u_bits,
776 		       sizeof(uuid_t));
777 		in_f->ilf_blkno = in_f64->ilf_blkno;
778 		in_f->ilf_len = in_f64->ilf_len;
779 		in_f->ilf_boffset = in_f64->ilf_boffset;
780 		return 0;
781 	}
782 	return -EFSCORRUPTED;
783 }
784