blob: a640137b357326de1d4df03ac63b9b918ec92588 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110020#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110021#include "xfs_log_format.h"
22#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_sb.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_inode.h"
Dave Chinner239880e2013-10-23 10:50:10 +110027#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110028#include "xfs_inode_item.h"
David Chinnerdb7a19f2008-04-10 12:22:24 +100029#include "xfs_error.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000030#include "xfs_trace.h"
Dave Chinner239880e2013-10-23 10:50:10 +110031#include "xfs_trans_priv.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110032#include "xfs_dinode.h"
Christoph Hellwig12343512013-12-13 11:00:43 +110033#include "xfs_log.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35
36kmem_zone_t *xfs_ili_zone; /* inode log item zone */
37
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100038static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
39{
40 return container_of(lip, struct xfs_inode_log_item, ili_item);
41}
42
Christoph Hellwigce9641d2013-12-13 11:00:43 +110043STATIC void
44xfs_inode_item_data_fork_size(
45 struct xfs_inode_log_item *iip,
46 int *nvecs,
47 int *nbytes)
48{
49 struct xfs_inode *ip = iip->ili_inode;
50
51 switch (ip->i_d.di_format) {
52 case XFS_DINODE_FMT_EXTENTS:
53 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
54 ip->i_d.di_nextents > 0 &&
55 ip->i_df.if_bytes > 0) {
56 /* worst case, doesn't subtract delalloc extents */
57 *nbytes += XFS_IFORK_DSIZE(ip);
58 *nvecs += 1;
59 }
60 break;
61 case XFS_DINODE_FMT_BTREE:
62 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
63 ip->i_df.if_broot_bytes > 0) {
64 *nbytes += ip->i_df.if_broot_bytes;
65 *nvecs += 1;
66 }
67 break;
68 case XFS_DINODE_FMT_LOCAL:
69 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
70 ip->i_df.if_bytes > 0) {
71 *nbytes += roundup(ip->i_df.if_bytes, 4);
72 *nvecs += 1;
73 }
74 break;
75
76 case XFS_DINODE_FMT_DEV:
77 case XFS_DINODE_FMT_UUID:
78 break;
79 default:
80 ASSERT(0);
81 break;
82 }
83}
84
85STATIC void
86xfs_inode_item_attr_fork_size(
87 struct xfs_inode_log_item *iip,
88 int *nvecs,
89 int *nbytes)
90{
91 struct xfs_inode *ip = iip->ili_inode;
92
93 switch (ip->i_d.di_aformat) {
94 case XFS_DINODE_FMT_EXTENTS:
95 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
96 ip->i_d.di_anextents > 0 &&
97 ip->i_afp->if_bytes > 0) {
98 /* worst case, doesn't subtract unused space */
99 *nbytes += XFS_IFORK_ASIZE(ip);
100 *nvecs += 1;
101 }
102 break;
103 case XFS_DINODE_FMT_BTREE:
104 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
105 ip->i_afp->if_broot_bytes > 0) {
106 *nbytes += ip->i_afp->if_broot_bytes;
107 *nvecs += 1;
108 }
109 break;
110 case XFS_DINODE_FMT_LOCAL:
111 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
112 ip->i_afp->if_bytes > 0) {
113 *nbytes += roundup(ip->i_afp->if_bytes, 4);
114 *nvecs += 1;
115 }
116 break;
117 default:
118 ASSERT(0);
119 break;
120 }
121}
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123/*
124 * This returns the number of iovecs needed to log the given inode item.
125 *
126 * We need one iovec for the inode log format structure, one for the
127 * inode core, and possibly one for the inode data/extents/b-tree root
128 * and one for the inode attribute data/extents/b-tree root.
129 */
Dave Chinner166d1362013-08-12 20:50:04 +1000130STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131xfs_inode_item_size(
Dave Chinner166d1362013-08-12 20:50:04 +1000132 struct xfs_log_item *lip,
133 int *nvecs,
134 int *nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000136 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
137 struct xfs_inode *ip = iip->ili_inode;
Dave Chinner166d1362013-08-12 20:50:04 +1000138
139 *nvecs += 2;
140 *nbytes += sizeof(struct xfs_inode_log_format) +
141 xfs_icdinode_size(ip->i_d.di_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Christoph Hellwigce9641d2013-12-13 11:00:43 +1100143 xfs_inode_item_data_fork_size(iip, nvecs, nbytes);
144 if (XFS_IFORK_Q(ip))
145 xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146}
147
Christoph Hellwig12343512013-12-13 11:00:43 +1100148STATIC void
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100149xfs_inode_item_format_data_fork(
150 struct xfs_inode_log_item *iip,
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100151 struct xfs_inode_log_format *ilf,
152 struct xfs_log_vec *lv,
153 struct xfs_log_iovec **vecp)
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100154{
155 struct xfs_inode *ip = iip->ili_inode;
156 size_t data_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 switch (ip->i_d.di_format) {
159 case XFS_DINODE_FMT_EXTENTS:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000160 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000161 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
162 XFS_ILOG_DEV | XFS_ILOG_UUID);
163
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000164 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000165 ip->i_d.di_nextents > 0 &&
166 ip->i_df.if_bytes > 0) {
Christoph Hellwigda776502013-12-13 11:34:04 +1100167 struct xfs_bmbt_rec *p;
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 ASSERT(ip->i_df.if_u1.if_extents != NULL);
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000170 ASSERT(ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) > 0);
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000171
Christoph Hellwigda776502013-12-13 11:34:04 +1100172 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
173 data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
174 xlog_finish_iovec(lv, *vecp, data_bytes);
175
176 ASSERT(data_bytes <= ip->i_df.if_bytes);
177
178 ilf->ilf_dsize = data_bytes;
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100179 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000180 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000181 iip->ili_fields &= ~XFS_ILOG_DEXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 }
183 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 case XFS_DINODE_FMT_BTREE:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000185 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000186 ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
187 XFS_ILOG_DEV | XFS_ILOG_UUID);
188
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000189 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000190 ip->i_df.if_broot_bytes > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 ASSERT(ip->i_df.if_broot != NULL);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100192 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
Christoph Hellwig12343512013-12-13 11:00:43 +1100193 ip->i_df.if_broot,
194 ip->i_df.if_broot_bytes);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100195 ilf->ilf_dsize = ip->i_df.if_broot_bytes;
196 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000197 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000198 ASSERT(!(iip->ili_fields &
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000199 XFS_ILOG_DBROOT));
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000200 iip->ili_fields &= ~XFS_ILOG_DBROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 }
202 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 case XFS_DINODE_FMT_LOCAL:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000204 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000205 ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
206 XFS_ILOG_DEV | XFS_ILOG_UUID);
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000207 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000208 ip->i_df.if_bytes > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 /*
210 * Round i_bytes up to a word boundary.
211 * The underlying memory is guaranteed to
212 * to be there by xfs_idata_realloc().
213 */
214 data_bytes = roundup(ip->i_df.if_bytes, 4);
Christoph Hellwig12343512013-12-13 11:00:43 +1100215 ASSERT(ip->i_df.if_real_bytes == 0 ||
216 ip->i_df.if_real_bytes == data_bytes);
217 ASSERT(ip->i_df.if_u1.if_data != NULL);
218 ASSERT(ip->i_d.di_size > 0);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100219 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
Christoph Hellwig12343512013-12-13 11:00:43 +1100220 ip->i_df.if_u1.if_data, data_bytes);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100221 ilf->ilf_dsize = (unsigned)data_bytes;
222 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000223 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000224 iip->ili_fields &= ~XFS_ILOG_DDATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 case XFS_DINODE_FMT_DEV:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000228 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000229 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
230 XFS_ILOG_DEXT | XFS_ILOG_UUID);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100231 if (iip->ili_fields & XFS_ILOG_DEV)
232 ilf->ilf_u.ilfu_rdev = ip->i_df.if_u2.if_rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 case XFS_DINODE_FMT_UUID:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000235 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000236 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
237 XFS_ILOG_DEXT | XFS_ILOG_DEV);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100238 if (iip->ili_fields & XFS_ILOG_UUID)
239 ilf->ilf_u.ilfu_uuid = ip->i_df.if_u2.if_uuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 default:
242 ASSERT(0);
243 break;
244 }
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100245}
246
Christoph Hellwig12343512013-12-13 11:00:43 +1100247STATIC void
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100248xfs_inode_item_format_attr_fork(
249 struct xfs_inode_log_item *iip,
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100250 struct xfs_inode_log_format *ilf,
251 struct xfs_log_vec *lv,
252 struct xfs_log_iovec **vecp)
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100253{
254 struct xfs_inode *ip = iip->ili_inode;
255 size_t data_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 switch (ip->i_d.di_aformat) {
258 case XFS_DINODE_FMT_EXTENTS:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000259 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000260 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
261
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000262 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000263 ip->i_d.di_anextents > 0 &&
264 ip->i_afp->if_bytes > 0) {
Christoph Hellwigda776502013-12-13 11:34:04 +1100265 struct xfs_bmbt_rec *p;
266
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000267 ASSERT(ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) ==
268 ip->i_d.di_anextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 ASSERT(ip->i_afp->if_u1.if_extents != NULL);
Christoph Hellwigda776502013-12-13 11:34:04 +1100270
271 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
272 data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
273 xlog_finish_iovec(lv, *vecp, data_bytes);
274
275 ilf->ilf_asize = data_bytes;
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100276 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000277 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000278 iip->ili_fields &= ~XFS_ILOG_AEXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 case XFS_DINODE_FMT_BTREE:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000282 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000283 ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
284
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000285 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000286 ip->i_afp->if_broot_bytes > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 ASSERT(ip->i_afp->if_broot != NULL);
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000288
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100289 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
Christoph Hellwig12343512013-12-13 11:00:43 +1100290 ip->i_afp->if_broot,
291 ip->i_afp->if_broot_bytes);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100292 ilf->ilf_asize = ip->i_afp->if_broot_bytes;
293 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000294 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000295 iip->ili_fields &= ~XFS_ILOG_ABROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
297 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 case XFS_DINODE_FMT_LOCAL:
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000299 iip->ili_fields &=
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000300 ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
301
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000302 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000303 ip->i_afp->if_bytes > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 /*
305 * Round i_bytes up to a word boundary.
306 * The underlying memory is guaranteed to
307 * to be there by xfs_idata_realloc().
308 */
309 data_bytes = roundup(ip->i_afp->if_bytes, 4);
Christoph Hellwig12343512013-12-13 11:00:43 +1100310 ASSERT(ip->i_afp->if_real_bytes == 0 ||
311 ip->i_afp->if_real_bytes == data_bytes);
312 ASSERT(ip->i_afp->if_u1.if_data != NULL);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100313 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
Christoph Hellwig12343512013-12-13 11:00:43 +1100314 ip->i_afp->if_u1.if_data,
315 data_bytes);
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100316 ilf->ilf_asize = (unsigned)data_bytes;
317 ilf->ilf_size++;
Christoph Hellwig339a5f52012-02-29 09:53:53 +0000318 } else {
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000319 iip->ili_fields &= ~XFS_ILOG_ADATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
321 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 default:
323 ASSERT(0);
324 break;
325 }
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100326}
327
328/*
329 * This is called to fill in the vector of log iovecs for the given inode
330 * log item. It fills the first item with an inode log format structure,
331 * the second with the on-disk inode structure, and a possible third and/or
332 * fourth with the inode data/extents/b-tree root and inode attributes
333 * data/extents/b-tree root.
334 */
335STATIC void
336xfs_inode_item_format(
337 struct xfs_log_item *lip,
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100338 struct xfs_log_vec *lv)
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100339{
340 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
341 struct xfs_inode *ip = iip->ili_inode;
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100342 struct xfs_inode_log_format *ilf;
343 struct xfs_log_iovec *vecp = NULL;
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100344
Dave Chinner263997a2014-05-20 07:46:40 +1000345 ASSERT(ip->i_d.di_version > 1);
346
Christoph Hellwig2f251292013-12-13 11:34:05 +1100347 ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
348 ilf->ilf_type = XFS_LI_INODE;
349 ilf->ilf_ino = ip->i_ino;
350 ilf->ilf_blkno = ip->i_imap.im_blkno;
351 ilf->ilf_len = ip->i_imap.im_len;
352 ilf->ilf_boffset = ip->i_imap.im_boffset;
353 ilf->ilf_fields = XFS_ILOG_CORE;
354 ilf->ilf_size = 2; /* format + core */
355 xlog_finish_iovec(lv, vecp, sizeof(struct xfs_inode_log_format));
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100356
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100357 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ICORE,
358 &ip->i_d,
359 xfs_icdinode_size(ip->i_d.di_version));
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100360
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100361 xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100362 if (XFS_IFORK_Q(ip)) {
Christoph Hellwigbde7cff2013-12-13 11:34:02 +1100363 xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
Christoph Hellwig3de559fb2013-12-13 11:00:43 +1100364 } else {
365 iip->ili_fields &=
366 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
367 }
368
Christoph Hellwig2f251292013-12-13 11:34:05 +1100369 /* update the format with the exact fields we actually logged */
370 ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373/*
374 * This is called to pin the inode associated with the inode log
Christoph Hellwiga14a5ab2010-02-18 12:43:22 +0000375 * item in memory so it cannot be written out.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 */
377STATIC void
378xfs_inode_item_pin(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000379 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000381 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
Christoph Hellwiga14a5ab2010-02-18 12:43:22 +0000382
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000383 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
384
385 trace_xfs_inode_pin(ip, _RET_IP_);
386 atomic_inc(&ip->i_pincount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
389
390/*
391 * This is called to unpin the inode associated with the inode log
392 * item which was previously pinned with a call to xfs_inode_item_pin().
Christoph Hellwiga14a5ab2010-02-18 12:43:22 +0000393 *
394 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396STATIC void
397xfs_inode_item_unpin(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000398 struct xfs_log_item *lip,
Christoph Hellwig9412e312010-06-23 18:11:15 +1000399 int remove)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000401 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
Christoph Hellwiga14a5ab2010-02-18 12:43:22 +0000402
Dave Chinner4aaf15d2010-03-08 11:24:07 +1100403 trace_xfs_inode_unpin(ip, _RET_IP_);
Christoph Hellwiga14a5ab2010-02-18 12:43:22 +0000404 ASSERT(atomic_read(&ip->i_pincount) > 0);
405 if (atomic_dec_and_test(&ip->i_pincount))
Christoph Hellwigf392e632011-12-18 20:00:10 +0000406 wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409STATIC uint
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000410xfs_inode_item_push(
411 struct xfs_log_item *lip,
412 struct list_head *buffer_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000414 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
415 struct xfs_inode *ip = iip->ili_inode;
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000416 struct xfs_buf *bp = NULL;
417 uint rval = XFS_ITEM_SUCCESS;
418 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000420 if (xfs_ipincount(ip) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return XFS_ITEM_PINNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000423 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return XFS_ITEM_LOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Christoph Hellwig4c468192012-04-23 15:58:36 +1000426 /*
427 * Re-check the pincount now that we stabilized the value by
428 * taking the ilock.
429 */
430 if (xfs_ipincount(ip) > 0) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000431 rval = XFS_ITEM_PINNED;
432 goto out_unlock;
Christoph Hellwig4c468192012-04-23 15:58:36 +1000433 }
434
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000435 /*
Brian Foster9a3a5da2012-06-11 10:39:43 -0400436 * Stale inode items should force out the iclog.
437 */
438 if (ip->i_flags & XFS_ISTALE) {
439 rval = XFS_ITEM_PINNED;
440 goto out_unlock;
441 }
442
443 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000444 * Someone else is already flushing the inode. Nothing we can do
445 * here but wait for the flush to finish and remove the item from
446 * the AIL.
447 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (!xfs_iflock_nowait(ip)) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000449 rval = XFS_ITEM_FLUSHING;
450 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 }
452
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000453 ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
454 ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
455
456 spin_unlock(&lip->li_ailp->xa_lock);
457
458 error = xfs_iflush(ip, &bp);
459 if (!error) {
460 if (!xfs_buf_delwri_queue(bp, buffer_list))
461 rval = XFS_ITEM_FLUSHING;
462 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000464
465 spin_lock(&lip->li_ailp->xa_lock);
466out_unlock:
467 xfs_iunlock(ip, XFS_ILOCK_SHARED);
468 return rval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
471/*
472 * Unlock the inode associated with the inode log item.
473 * Clear the fields of the inode and inode log item that
474 * are specific to the current transaction. If the
475 * hold flags is set, do not unlock the inode.
476 */
477STATIC void
478xfs_inode_item_unlock(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000479 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000481 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
482 struct xfs_inode *ip = iip->ili_inode;
Christoph Hellwig898621d2010-06-24 11:36:58 +1000483 unsigned short lock_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Christoph Hellwigf3ca87382011-07-08 14:34:47 +0200485 ASSERT(ip->i_itemp != NULL);
486 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Christoph Hellwig898621d2010-06-24 11:36:58 +1000488 lock_flags = iip->ili_lock_flags;
489 iip->ili_lock_flags = 0;
Christoph Hellwigddc34152011-09-19 15:00:54 +0000490 if (lock_flags)
Christoph Hellwigf3ca87382011-07-08 14:34:47 +0200491 xfs_iunlock(ip, lock_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492}
493
494/*
Dave Chinnerde25c182010-11-30 15:15:46 +1100495 * This is called to find out where the oldest active copy of the inode log
496 * item in the on disk log resides now that the last log write of it completed
497 * at the given lsn. Since we always re-log all dirty data in an inode, the
498 * latest copy in the on disk log is the only one that matters. Therefore,
499 * simply return the given lsn.
500 *
501 * If the inode has been marked stale because the cluster is being freed, we
502 * don't want to (re-)insert this inode into the AIL. There is a race condition
503 * where the cluster buffer may be unpinned before the inode is inserted into
504 * the AIL during transaction committed processing. If the buffer is unpinned
505 * before the inode item has been committed and inserted, then it is possible
Dave Chinner1316d4d2011-07-04 05:27:36 +0000506 * for the buffer to be written and IO completes before the inode is inserted
Dave Chinnerde25c182010-11-30 15:15:46 +1100507 * into the AIL. In that case, we'd be inserting a clean, stale inode into the
508 * AIL which will never get removed. It will, however, get reclaimed which
509 * triggers an assert in xfs_inode_free() complaining about freein an inode
510 * still in the AIL.
511 *
Dave Chinner1316d4d2011-07-04 05:27:36 +0000512 * To avoid this, just unpin the inode directly and return a LSN of -1 so the
513 * transaction committed code knows that it does not need to do any further
514 * processing on the item.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516STATIC xfs_lsn_t
517xfs_inode_item_committed(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000518 struct xfs_log_item *lip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 xfs_lsn_t lsn)
520{
Dave Chinnerde25c182010-11-30 15:15:46 +1100521 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
522 struct xfs_inode *ip = iip->ili_inode;
523
Dave Chinner1316d4d2011-07-04 05:27:36 +0000524 if (xfs_iflags_test(ip, XFS_ISTALE)) {
525 xfs_inode_item_unpin(lip, 0);
526 return -1;
527 }
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000528 return lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529}
530
531/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 * XXX rcc - this one really has to do something. Probably needs
533 * to stamp in a new field in the incore inode.
534 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535STATIC void
536xfs_inode_item_committing(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000537 struct xfs_log_item *lip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 xfs_lsn_t lsn)
539{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000540 INODE_ITEM(lip)->ili_last_lsn = lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
542
543/*
544 * This is the ops vector shared by all buf log items.
545 */
Christoph Hellwig272e42b2011-10-28 09:54:24 +0000546static const struct xfs_item_ops xfs_inode_item_ops = {
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000547 .iop_size = xfs_inode_item_size,
548 .iop_format = xfs_inode_item_format,
549 .iop_pin = xfs_inode_item_pin,
550 .iop_unpin = xfs_inode_item_unpin,
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000551 .iop_unlock = xfs_inode_item_unlock,
552 .iop_committed = xfs_inode_item_committed,
553 .iop_push = xfs_inode_item_push,
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000554 .iop_committing = xfs_inode_item_committing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555};
556
557
558/*
559 * Initialize the inode log item for a newly allocated (in-core) inode.
560 */
561void
562xfs_inode_item_init(
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000563 struct xfs_inode *ip,
564 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000566 struct xfs_inode_log_item *iip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 ASSERT(ip->i_itemp == NULL);
569 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP);
570
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 iip->ili_inode = ip;
Dave Chinner43f5efc2010-03-23 10:10:00 +1100572 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
573 &xfs_inode_item_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574}
575
576/*
577 * Free the inode log item and any memory hanging off of it.
578 */
579void
580xfs_inode_item_destroy(
581 xfs_inode_t *ip)
582{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 kmem_zone_free(xfs_ili_zone, ip->i_itemp);
584}
585
586
587/*
588 * This is the inode flushing I/O completion routine. It is called
589 * from interrupt level when the buffer containing the inode is
590 * flushed to disk. It is responsible for removing the inode item
591 * from the AIL if it has not been re-logged, and unlocking the inode's
592 * flush lock.
Dave Chinner30136832010-12-20 12:03:17 +1100593 *
594 * To reduce AIL lock traffic as much as possible, we scan the buffer log item
595 * list for other inodes that will run this function. We remove them from the
596 * buffer list so we can process all the inode IO completions in one AIL lock
597 * traversal.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599void
600xfs_iflush_done(
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000601 struct xfs_buf *bp,
602 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603{
Dave Chinner30136832010-12-20 12:03:17 +1100604 struct xfs_inode_log_item *iip;
605 struct xfs_log_item *blip;
606 struct xfs_log_item *next;
607 struct xfs_log_item *prev;
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000608 struct xfs_ail *ailp = lip->li_ailp;
Dave Chinner30136832010-12-20 12:03:17 +1100609 int need_ail = 0;
610
611 /*
612 * Scan the buffer IO completions for other inodes being completed and
613 * attach them to the current inode log item.
614 */
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200615 blip = bp->b_fspriv;
Dave Chinner30136832010-12-20 12:03:17 +1100616 prev = NULL;
617 while (blip != NULL) {
618 if (lip->li_cb != xfs_iflush_done) {
619 prev = blip;
620 blip = blip->li_bio_list;
621 continue;
622 }
623
624 /* remove from list */
625 next = blip->li_bio_list;
626 if (!prev) {
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200627 bp->b_fspriv = next;
Dave Chinner30136832010-12-20 12:03:17 +1100628 } else {
629 prev->li_bio_list = next;
630 }
631
632 /* add to current list */
633 blip->li_bio_list = lip->li_bio_list;
634 lip->li_bio_list = blip;
635
636 /*
637 * while we have the item, do the unlocked check for needing
638 * the AIL lock.
639 */
640 iip = INODE_ITEM(blip);
641 if (iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn)
642 need_ail++;
643
644 blip = next;
645 }
646
647 /* make sure we capture the state of the initial inode. */
648 iip = INODE_ITEM(lip);
649 if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn)
650 need_ail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 /*
653 * We only want to pull the item from the AIL if it is
654 * actually there and its location in the log has not
655 * changed since we started the flush. Thus, we only bother
656 * if the ili_logged flag is set and the inode's lsn has not
657 * changed. First we check the lsn outside
658 * the lock since it's cheaper, and then we recheck while
659 * holding the lock before removing the inode from the AIL.
660 */
Dave Chinner30136832010-12-20 12:03:17 +1100661 if (need_ail) {
662 struct xfs_log_item *log_items[need_ail];
663 int i = 0;
David Chinner783a2f62008-10-30 17:39:58 +1100664 spin_lock(&ailp->xa_lock);
Dave Chinner30136832010-12-20 12:03:17 +1100665 for (blip = lip; blip; blip = blip->li_bio_list) {
666 iip = INODE_ITEM(blip);
667 if (iip->ili_logged &&
668 blip->li_lsn == iip->ili_flush_lsn) {
669 log_items[i++] = blip;
670 }
671 ASSERT(i <= need_ail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
Dave Chinner30136832010-12-20 12:03:17 +1100673 /* xfs_trans_ail_delete_bulk() drops the AIL lock. */
Dave Chinner04913fd2012-04-23 15:58:41 +1000674 xfs_trans_ail_delete_bulk(ailp, log_items, i,
675 SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 }
677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 /*
Dave Chinner30136832010-12-20 12:03:17 +1100680 * clean up and unlock the flush lock now we are done. We can clear the
681 * ili_last_fields bits now that we know that the data corresponding to
682 * them is safely on disk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 */
Dave Chinner30136832010-12-20 12:03:17 +1100684 for (blip = lip; blip; blip = next) {
685 next = blip->li_bio_list;
686 blip->li_bio_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Dave Chinner30136832010-12-20 12:03:17 +1100688 iip = INODE_ITEM(blip);
689 iip->ili_logged = 0;
690 iip->ili_last_fields = 0;
691 xfs_ifunlock(iip->ili_inode);
692 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693}
694
695/*
Dave Chinner04913fd2012-04-23 15:58:41 +1000696 * This is the inode flushing abort routine. It is called from xfs_iflush when
697 * the filesystem is shutting down to clean up the inode state. It is
698 * responsible for removing the inode item from the AIL if it has not been
699 * re-logged, and unlocking the inode's flush lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 */
701void
702xfs_iflush_abort(
Dave Chinner04913fd2012-04-23 15:58:41 +1000703 xfs_inode_t *ip,
704 bool stale)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
David Chinner783a2f62008-10-30 17:39:58 +1100706 xfs_inode_log_item_t *iip = ip->i_itemp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (iip) {
David Chinner783a2f62008-10-30 17:39:58 +1100709 struct xfs_ail *ailp = iip->ili_item.li_ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
David Chinner783a2f62008-10-30 17:39:58 +1100711 spin_lock(&ailp->xa_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
David Chinner783a2f62008-10-30 17:39:58 +1100713 /* xfs_trans_ail_delete() drops the AIL lock. */
Dave Chinner04913fd2012-04-23 15:58:41 +1000714 xfs_trans_ail_delete(ailp, &iip->ili_item,
715 stale ?
716 SHUTDOWN_LOG_IO_ERROR :
717 SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 } else
David Chinner783a2f62008-10-30 17:39:58 +1100719 spin_unlock(&ailp->xa_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 }
721 iip->ili_logged = 0;
722 /*
723 * Clear the ili_last_fields bits now that we know that the
724 * data corresponding to them is safely on disk.
725 */
726 iip->ili_last_fields = 0;
727 /*
728 * Clear the inode logging fields so no more flushes are
729 * attempted.
730 */
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +0000731 iip->ili_fields = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
733 /*
734 * Release the inode's flush lock since we're done with it.
735 */
736 xfs_ifunlock(ip);
737}
738
739void
740xfs_istale_done(
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000741 struct xfs_buf *bp,
742 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
Dave Chinner04913fd2012-04-23 15:58:41 +1000744 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
Tim Shimmin6d192a92006-06-09 14:55:38 +1000746
747/*
748 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
749 * (which can have different field alignments) to the native version
750 */
751int
752xfs_inode_item_format_convert(
753 xfs_log_iovec_t *buf,
754 xfs_inode_log_format_t *in_f)
755{
756 if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000757 xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +1000758
Tim Shimmin6d192a92006-06-09 14:55:38 +1000759 in_f->ilf_type = in_f32->ilf_type;
760 in_f->ilf_size = in_f32->ilf_size;
761 in_f->ilf_fields = in_f32->ilf_fields;
762 in_f->ilf_asize = in_f32->ilf_asize;
763 in_f->ilf_dsize = in_f32->ilf_dsize;
764 in_f->ilf_ino = in_f32->ilf_ino;
765 /* copy biggest field of ilf_u */
766 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
767 in_f32->ilf_u.ilfu_uuid.__u_bits,
768 sizeof(uuid_t));
769 in_f->ilf_blkno = in_f32->ilf_blkno;
770 in_f->ilf_len = in_f32->ilf_len;
771 in_f->ilf_boffset = in_f32->ilf_boffset;
772 return 0;
773 } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000774 xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +1000775
Tim Shimmin6d192a92006-06-09 14:55:38 +1000776 in_f->ilf_type = in_f64->ilf_type;
777 in_f->ilf_size = in_f64->ilf_size;
778 in_f->ilf_fields = in_f64->ilf_fields;
779 in_f->ilf_asize = in_f64->ilf_asize;
780 in_f->ilf_dsize = in_f64->ilf_dsize;
781 in_f->ilf_ino = in_f64->ilf_ino;
782 /* copy biggest field of ilf_u */
783 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
784 in_f64->ilf_u.ilfu_uuid.__u_bits,
785 sizeof(uuid_t));
786 in_f->ilf_blkno = in_f64->ilf_blkno;
787 in_f->ilf_len = in_f64->ilf_len;
788 in_f->ilf_boffset = in_f64->ilf_boffset;
789 return 0;
790 }
791 return EFSCORRUPTED;
792}