Merge branch 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / fs / xfs / xfs_inode_item.c
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_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_mount.h"
28 #include "xfs_trans_priv.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_dinode.h"
31 #include "xfs_inode.h"
32 #include "xfs_inode_item.h"
33 #include "xfs_error.h"
34 #include "xfs_trace.h"
35
36
37 kmem_zone_t     *xfs_ili_zone;          /* inode log item zone */
38
39 static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
40 {
41         return container_of(lip, struct xfs_inode_log_item, ili_item);
42 }
43
44
45 /*
46  * This returns the number of iovecs needed to log the given inode item.
47  *
48  * We need one iovec for the inode log format structure, one for the
49  * inode core, and possibly one for the inode data/extents/b-tree root
50  * and one for the inode attribute data/extents/b-tree root.
51  */
52 STATIC uint
53 xfs_inode_item_size(
54         struct xfs_log_item     *lip)
55 {
56         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
57         struct xfs_inode        *ip = iip->ili_inode;
58         uint                    nvecs = 2;
59
60         /*
61          * Only log the data/extents/b-tree root if there is something
62          * left to log.
63          */
64         iip->ili_format.ilf_fields |= XFS_ILOG_CORE;
65
66         switch (ip->i_d.di_format) {
67         case XFS_DINODE_FMT_EXTENTS:
68                 iip->ili_format.ilf_fields &=
69                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
70                           XFS_ILOG_DEV | XFS_ILOG_UUID);
71                 if ((iip->ili_format.ilf_fields & XFS_ILOG_DEXT) &&
72                     (ip->i_d.di_nextents > 0) &&
73                     (ip->i_df.if_bytes > 0)) {
74                         ASSERT(ip->i_df.if_u1.if_extents != NULL);
75                         nvecs++;
76                 } else {
77                         iip->ili_format.ilf_fields &= ~XFS_ILOG_DEXT;
78                 }
79                 break;
80
81         case XFS_DINODE_FMT_BTREE:
82                 ASSERT(ip->i_df.if_ext_max ==
83                        XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t));
84                 iip->ili_format.ilf_fields &=
85                         ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
86                           XFS_ILOG_DEV | XFS_ILOG_UUID);
87                 if ((iip->ili_format.ilf_fields & XFS_ILOG_DBROOT) &&
88                     (ip->i_df.if_broot_bytes > 0)) {
89                         ASSERT(ip->i_df.if_broot != NULL);
90                         nvecs++;
91                 } else {
92                         ASSERT(!(iip->ili_format.ilf_fields &
93                                  XFS_ILOG_DBROOT));
94 #ifdef XFS_TRANS_DEBUG
95                         if (iip->ili_root_size > 0) {
96                                 ASSERT(iip->ili_root_size ==
97                                        ip->i_df.if_broot_bytes);
98                                 ASSERT(memcmp(iip->ili_orig_root,
99                                             ip->i_df.if_broot,
100                                             iip->ili_root_size) == 0);
101                         } else {
102                                 ASSERT(ip->i_df.if_broot_bytes == 0);
103                         }
104 #endif
105                         iip->ili_format.ilf_fields &= ~XFS_ILOG_DBROOT;
106                 }
107                 break;
108
109         case XFS_DINODE_FMT_LOCAL:
110                 iip->ili_format.ilf_fields &=
111                         ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
112                           XFS_ILOG_DEV | XFS_ILOG_UUID);
113                 if ((iip->ili_format.ilf_fields & XFS_ILOG_DDATA) &&
114                     (ip->i_df.if_bytes > 0)) {
115                         ASSERT(ip->i_df.if_u1.if_data != NULL);
116                         ASSERT(ip->i_d.di_size > 0);
117                         nvecs++;
118                 } else {
119                         iip->ili_format.ilf_fields &= ~XFS_ILOG_DDATA;
120                 }
121                 break;
122
123         case XFS_DINODE_FMT_DEV:
124                 iip->ili_format.ilf_fields &=
125                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
126                           XFS_ILOG_DEXT | XFS_ILOG_UUID);
127                 break;
128
129         case XFS_DINODE_FMT_UUID:
130                 iip->ili_format.ilf_fields &=
131                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
132                           XFS_ILOG_DEXT | XFS_ILOG_DEV);
133                 break;
134
135         default:
136                 ASSERT(0);
137                 break;
138         }
139
140         /*
141          * If there are no attributes associated with this file,
142          * then there cannot be anything more to log.
143          * Clear all attribute-related log flags.
144          */
145         if (!XFS_IFORK_Q(ip)) {
146                 iip->ili_format.ilf_fields &=
147                         ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
148                 return nvecs;
149         }
150
151         /*
152          * Log any necessary attribute data.
153          */
154         switch (ip->i_d.di_aformat) {
155         case XFS_DINODE_FMT_EXTENTS:
156                 iip->ili_format.ilf_fields &=
157                         ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
158                 if ((iip->ili_format.ilf_fields & XFS_ILOG_AEXT) &&
159                     (ip->i_d.di_anextents > 0) &&
160                     (ip->i_afp->if_bytes > 0)) {
161                         ASSERT(ip->i_afp->if_u1.if_extents != NULL);
162                         nvecs++;
163                 } else {
164                         iip->ili_format.ilf_fields &= ~XFS_ILOG_AEXT;
165                 }
166                 break;
167
168         case XFS_DINODE_FMT_BTREE:
169                 iip->ili_format.ilf_fields &=
170                         ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
171                 if ((iip->ili_format.ilf_fields & XFS_ILOG_ABROOT) &&
172                     (ip->i_afp->if_broot_bytes > 0)) {
173                         ASSERT(ip->i_afp->if_broot != NULL);
174                         nvecs++;
175                 } else {
176                         iip->ili_format.ilf_fields &= ~XFS_ILOG_ABROOT;
177                 }
178                 break;
179
180         case XFS_DINODE_FMT_LOCAL:
181                 iip->ili_format.ilf_fields &=
182                         ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
183                 if ((iip->ili_format.ilf_fields & XFS_ILOG_ADATA) &&
184                     (ip->i_afp->if_bytes > 0)) {
185                         ASSERT(ip->i_afp->if_u1.if_data != NULL);
186                         nvecs++;
187                 } else {
188                         iip->ili_format.ilf_fields &= ~XFS_ILOG_ADATA;
189                 }
190                 break;
191
192         default:
193                 ASSERT(0);
194                 break;
195         }
196
197         return nvecs;
198 }
199
200 /*
201  * xfs_inode_item_format_extents - convert in-core extents to on-disk form
202  *
203  * For either the data or attr fork in extent format, we need to endian convert
204  * the in-core extent as we place them into the on-disk inode. In this case, we
205  * need to do this conversion before we write the extents into the log. Because
206  * we don't have the disk inode to write into here, we allocate a buffer and
207  * format the extents into it via xfs_iextents_copy(). We free the buffer in
208  * the unlock routine after the copy for the log has been made.
209  *
210  * In the case of the data fork, the in-core and on-disk fork sizes can be
211  * different due to delayed allocation extents. We only log on-disk extents
212  * here, so always use the physical fork size to determine the size of the
213  * buffer we need to allocate.
214  */
215 STATIC void
216 xfs_inode_item_format_extents(
217         struct xfs_inode        *ip,
218         struct xfs_log_iovec    *vecp,
219         int                     whichfork,
220         int                     type)
221 {
222         xfs_bmbt_rec_t          *ext_buffer;
223
224         ext_buffer = kmem_alloc(XFS_IFORK_SIZE(ip, whichfork), KM_SLEEP);
225         if (whichfork == XFS_DATA_FORK)
226                 ip->i_itemp->ili_extents_buf = ext_buffer;
227         else
228                 ip->i_itemp->ili_aextents_buf = ext_buffer;
229
230         vecp->i_addr = ext_buffer;
231         vecp->i_len = xfs_iextents_copy(ip, ext_buffer, whichfork);
232         vecp->i_type = type;
233 }
234
235 /*
236  * This is called to fill in the vector of log iovecs for the
237  * given inode log item.  It fills the first item with an inode
238  * log format structure, the second with the on-disk inode structure,
239  * and a possible third and/or fourth with the inode data/extents/b-tree
240  * root and inode attributes data/extents/b-tree root.
241  */
242 STATIC void
243 xfs_inode_item_format(
244         struct xfs_log_item     *lip,
245         struct xfs_log_iovec    *vecp)
246 {
247         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
248         struct xfs_inode        *ip = iip->ili_inode;
249         uint                    nvecs;
250         size_t                  data_bytes;
251         xfs_mount_t             *mp;
252
253         vecp->i_addr = &iip->ili_format;
254         vecp->i_len  = sizeof(xfs_inode_log_format_t);
255         vecp->i_type = XLOG_REG_TYPE_IFORMAT;
256         vecp++;
257         nvecs        = 1;
258
259         /*
260          * Clear i_update_core if the timestamps (or any other
261          * non-transactional modification) need flushing/logging
262          * and we're about to log them with the rest of the core.
263          *
264          * This is the same logic as xfs_iflush() but this code can't
265          * run at the same time as xfs_iflush because we're in commit
266          * processing here and so we have the inode lock held in
267          * exclusive mode.  Although it doesn't really matter
268          * for the timestamps if both routines were to grab the
269          * timestamps or not.  That would be ok.
270          *
271          * We clear i_update_core before copying out the data.
272          * This is for coordination with our timestamp updates
273          * that don't hold the inode lock. They will always
274          * update the timestamps BEFORE setting i_update_core,
275          * so if we clear i_update_core after they set it we
276          * are guaranteed to see their updates to the timestamps
277          * either here.  Likewise, if they set it after we clear it
278          * here, we'll see it either on the next commit of this
279          * inode or the next time the inode gets flushed via
280          * xfs_iflush().  This depends on strongly ordered memory
281          * semantics, but we have that.  We use the SYNCHRONIZE
282          * macro to make sure that the compiler does not reorder
283          * the i_update_core access below the data copy below.
284          */
285         if (ip->i_update_core)  {
286                 ip->i_update_core = 0;
287                 SYNCHRONIZE();
288         }
289
290         /*
291          * Make sure to get the latest timestamps from the Linux inode.
292          */
293         xfs_synchronize_times(ip);
294
295         vecp->i_addr = &ip->i_d;
296         vecp->i_len  = sizeof(struct xfs_icdinode);
297         vecp->i_type = XLOG_REG_TYPE_ICORE;
298         vecp++;
299         nvecs++;
300         iip->ili_format.ilf_fields |= XFS_ILOG_CORE;
301
302         /*
303          * If this is really an old format inode, then we need to
304          * log it as such.  This means that we have to copy the link
305          * count from the new field to the old.  We don't have to worry
306          * about the new fields, because nothing trusts them as long as
307          * the old inode version number is there.  If the superblock already
308          * has a new version number, then we don't bother converting back.
309          */
310         mp = ip->i_mount;
311         ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb));
312         if (ip->i_d.di_version == 1) {
313                 if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
314                         /*
315                          * Convert it back.
316                          */
317                         ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
318                         ip->i_d.di_onlink = ip->i_d.di_nlink;
319                 } else {
320                         /*
321                          * The superblock version has already been bumped,
322                          * so just make the conversion to the new inode
323                          * format permanent.
324                          */
325                         ip->i_d.di_version = 2;
326                         ip->i_d.di_onlink = 0;
327                         memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
328                 }
329         }
330
331         switch (ip->i_d.di_format) {
332         case XFS_DINODE_FMT_EXTENTS:
333                 ASSERT(!(iip->ili_format.ilf_fields &
334                          (XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
335                           XFS_ILOG_DEV | XFS_ILOG_UUID)));
336                 if (iip->ili_format.ilf_fields & XFS_ILOG_DEXT) {
337                         ASSERT(ip->i_df.if_bytes > 0);
338                         ASSERT(ip->i_df.if_u1.if_extents != NULL);
339                         ASSERT(ip->i_d.di_nextents > 0);
340                         ASSERT(iip->ili_extents_buf == NULL);
341                         ASSERT((ip->i_df.if_bytes /
342                                 (uint)sizeof(xfs_bmbt_rec_t)) > 0);
343 #ifdef XFS_NATIVE_HOST
344                        if (ip->i_d.di_nextents == ip->i_df.if_bytes /
345                                                (uint)sizeof(xfs_bmbt_rec_t)) {
346                                 /*
347                                  * There are no delayed allocation
348                                  * extents, so just point to the
349                                  * real extents array.
350                                  */
351                                 vecp->i_addr = ip->i_df.if_u1.if_extents;
352                                 vecp->i_len = ip->i_df.if_bytes;
353                                 vecp->i_type = XLOG_REG_TYPE_IEXT;
354                         } else
355 #endif
356                         {
357                                 xfs_inode_item_format_extents(ip, vecp,
358                                         XFS_DATA_FORK, XLOG_REG_TYPE_IEXT);
359                         }
360                         ASSERT(vecp->i_len <= ip->i_df.if_bytes);
361                         iip->ili_format.ilf_dsize = vecp->i_len;
362                         vecp++;
363                         nvecs++;
364                 }
365                 break;
366
367         case XFS_DINODE_FMT_BTREE:
368                 ASSERT(!(iip->ili_format.ilf_fields &
369                          (XFS_ILOG_DDATA | XFS_ILOG_DEXT |
370                           XFS_ILOG_DEV | XFS_ILOG_UUID)));
371                 if (iip->ili_format.ilf_fields & XFS_ILOG_DBROOT) {
372                         ASSERT(ip->i_df.if_broot_bytes > 0);
373                         ASSERT(ip->i_df.if_broot != NULL);
374                         vecp->i_addr = ip->i_df.if_broot;
375                         vecp->i_len = ip->i_df.if_broot_bytes;
376                         vecp->i_type = XLOG_REG_TYPE_IBROOT;
377                         vecp++;
378                         nvecs++;
379                         iip->ili_format.ilf_dsize = ip->i_df.if_broot_bytes;
380                 }
381                 break;
382
383         case XFS_DINODE_FMT_LOCAL:
384                 ASSERT(!(iip->ili_format.ilf_fields &
385                          (XFS_ILOG_DBROOT | XFS_ILOG_DEXT |
386                           XFS_ILOG_DEV | XFS_ILOG_UUID)));
387                 if (iip->ili_format.ilf_fields & XFS_ILOG_DDATA) {
388                         ASSERT(ip->i_df.if_bytes > 0);
389                         ASSERT(ip->i_df.if_u1.if_data != NULL);
390                         ASSERT(ip->i_d.di_size > 0);
391
392                         vecp->i_addr = ip->i_df.if_u1.if_data;
393                         /*
394                          * Round i_bytes up to a word boundary.
395                          * The underlying memory is guaranteed to
396                          * to be there by xfs_idata_realloc().
397                          */
398                         data_bytes = roundup(ip->i_df.if_bytes, 4);
399                         ASSERT((ip->i_df.if_real_bytes == 0) ||
400                                (ip->i_df.if_real_bytes == data_bytes));
401                         vecp->i_len = (int)data_bytes;
402                         vecp->i_type = XLOG_REG_TYPE_ILOCAL;
403                         vecp++;
404                         nvecs++;
405                         iip->ili_format.ilf_dsize = (unsigned)data_bytes;
406                 }
407                 break;
408
409         case XFS_DINODE_FMT_DEV:
410                 ASSERT(!(iip->ili_format.ilf_fields &
411                          (XFS_ILOG_DBROOT | XFS_ILOG_DEXT |
412                           XFS_ILOG_DDATA | XFS_ILOG_UUID)));
413                 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {
414                         iip->ili_format.ilf_u.ilfu_rdev =
415                                 ip->i_df.if_u2.if_rdev;
416                 }
417                 break;
418
419         case XFS_DINODE_FMT_UUID:
420                 ASSERT(!(iip->ili_format.ilf_fields &
421                          (XFS_ILOG_DBROOT | XFS_ILOG_DEXT |
422                           XFS_ILOG_DDATA | XFS_ILOG_DEV)));
423                 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
424                         iip->ili_format.ilf_u.ilfu_uuid =
425                                 ip->i_df.if_u2.if_uuid;
426                 }
427                 break;
428
429         default:
430                 ASSERT(0);
431                 break;
432         }
433
434         /*
435          * If there are no attributes associated with the file,
436          * then we're done.
437          * Assert that no attribute-related log flags are set.
438          */
439         if (!XFS_IFORK_Q(ip)) {
440                 ASSERT(nvecs == lip->li_desc->lid_size);
441                 iip->ili_format.ilf_size = nvecs;
442                 ASSERT(!(iip->ili_format.ilf_fields &
443                          (XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT)));
444                 return;
445         }
446
447         switch (ip->i_d.di_aformat) {
448         case XFS_DINODE_FMT_EXTENTS:
449                 ASSERT(!(iip->ili_format.ilf_fields &
450                          (XFS_ILOG_ADATA | XFS_ILOG_ABROOT)));
451                 if (iip->ili_format.ilf_fields & XFS_ILOG_AEXT) {
452 #ifdef DEBUG
453                         int nrecs = ip->i_afp->if_bytes /
454                                 (uint)sizeof(xfs_bmbt_rec_t);
455                         ASSERT(nrecs > 0);
456                         ASSERT(nrecs == ip->i_d.di_anextents);
457                         ASSERT(ip->i_afp->if_bytes > 0);
458                         ASSERT(ip->i_afp->if_u1.if_extents != NULL);
459                         ASSERT(ip->i_d.di_anextents > 0);
460 #endif
461 #ifdef XFS_NATIVE_HOST
462                         /*
463                          * There are not delayed allocation extents
464                          * for attributes, so just point at the array.
465                          */
466                         vecp->i_addr = ip->i_afp->if_u1.if_extents;
467                         vecp->i_len = ip->i_afp->if_bytes;
468                         vecp->i_type = XLOG_REG_TYPE_IATTR_EXT;
469 #else
470                         ASSERT(iip->ili_aextents_buf == NULL);
471                         xfs_inode_item_format_extents(ip, vecp,
472                                         XFS_ATTR_FORK, XLOG_REG_TYPE_IATTR_EXT);
473 #endif
474                         iip->ili_format.ilf_asize = vecp->i_len;
475                         vecp++;
476                         nvecs++;
477                 }
478                 break;
479
480         case XFS_DINODE_FMT_BTREE:
481                 ASSERT(!(iip->ili_format.ilf_fields &
482                          (XFS_ILOG_ADATA | XFS_ILOG_AEXT)));
483                 if (iip->ili_format.ilf_fields & XFS_ILOG_ABROOT) {
484                         ASSERT(ip->i_afp->if_broot_bytes > 0);
485                         ASSERT(ip->i_afp->if_broot != NULL);
486                         vecp->i_addr = ip->i_afp->if_broot;
487                         vecp->i_len = ip->i_afp->if_broot_bytes;
488                         vecp->i_type = XLOG_REG_TYPE_IATTR_BROOT;
489                         vecp++;
490                         nvecs++;
491                         iip->ili_format.ilf_asize = ip->i_afp->if_broot_bytes;
492                 }
493                 break;
494
495         case XFS_DINODE_FMT_LOCAL:
496                 ASSERT(!(iip->ili_format.ilf_fields &
497                          (XFS_ILOG_ABROOT | XFS_ILOG_AEXT)));
498                 if (iip->ili_format.ilf_fields & XFS_ILOG_ADATA) {
499                         ASSERT(ip->i_afp->if_bytes > 0);
500                         ASSERT(ip->i_afp->if_u1.if_data != NULL);
501
502                         vecp->i_addr = ip->i_afp->if_u1.if_data;
503                         /*
504                          * Round i_bytes up to a word boundary.
505                          * The underlying memory is guaranteed to
506                          * to be there by xfs_idata_realloc().
507                          */
508                         data_bytes = roundup(ip->i_afp->if_bytes, 4);
509                         ASSERT((ip->i_afp->if_real_bytes == 0) ||
510                                (ip->i_afp->if_real_bytes == data_bytes));
511                         vecp->i_len = (int)data_bytes;
512                         vecp->i_type = XLOG_REG_TYPE_IATTR_LOCAL;
513                         vecp++;
514                         nvecs++;
515                         iip->ili_format.ilf_asize = (unsigned)data_bytes;
516                 }
517                 break;
518
519         default:
520                 ASSERT(0);
521                 break;
522         }
523
524         ASSERT(nvecs == lip->li_desc->lid_size);
525         iip->ili_format.ilf_size = nvecs;
526 }
527
528
529 /*
530  * This is called to pin the inode associated with the inode log
531  * item in memory so it cannot be written out.
532  */
533 STATIC void
534 xfs_inode_item_pin(
535         struct xfs_log_item     *lip)
536 {
537         struct xfs_inode        *ip = INODE_ITEM(lip)->ili_inode;
538
539         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
540
541         trace_xfs_inode_pin(ip, _RET_IP_);
542         atomic_inc(&ip->i_pincount);
543 }
544
545
546 /*
547  * This is called to unpin the inode associated with the inode log
548  * item which was previously pinned with a call to xfs_inode_item_pin().
549  *
550  * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
551  */
552 STATIC void
553 xfs_inode_item_unpin(
554         struct xfs_log_item     *lip,
555         int                     remove)
556 {
557         struct xfs_inode        *ip = INODE_ITEM(lip)->ili_inode;
558
559         trace_xfs_inode_unpin(ip, _RET_IP_);
560         ASSERT(atomic_read(&ip->i_pincount) > 0);
561         if (atomic_dec_and_test(&ip->i_pincount))
562                 wake_up(&ip->i_ipin_wait);
563 }
564
565 /*
566  * This is called to attempt to lock the inode associated with this
567  * inode log item, in preparation for the push routine which does the actual
568  * iflush.  Don't sleep on the inode lock or the flush lock.
569  *
570  * If the flush lock is already held, indicating that the inode has
571  * been or is in the process of being flushed, then (ideally) we'd like to
572  * see if the inode's buffer is still incore, and if so give it a nudge.
573  * We delay doing so until the pushbuf routine, though, to avoid holding
574  * the AIL lock across a call to the blackhole which is the buffer cache.
575  * Also we don't want to sleep in any device strategy routines, which can happen
576  * if we do the subsequent bawrite in here.
577  */
578 STATIC uint
579 xfs_inode_item_trylock(
580         struct xfs_log_item     *lip)
581 {
582         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
583         struct xfs_inode        *ip = iip->ili_inode;
584
585         if (xfs_ipincount(ip) > 0)
586                 return XFS_ITEM_PINNED;
587
588         if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
589                 return XFS_ITEM_LOCKED;
590
591         if (!xfs_iflock_nowait(ip)) {
592                 /*
593                  * inode has already been flushed to the backing buffer,
594                  * leave it locked in shared mode, pushbuf routine will
595                  * unlock it.
596                  */
597                 return XFS_ITEM_PUSHBUF;
598         }
599
600         /* Stale items should force out the iclog */
601         if (ip->i_flags & XFS_ISTALE) {
602                 xfs_ifunlock(ip);
603                 /*
604                  * we hold the AIL lock - notify the unlock routine of this
605                  * so it doesn't try to get the lock again.
606                  */
607                 xfs_iunlock(ip, XFS_ILOCK_SHARED|XFS_IUNLOCK_NONOTIFY);
608                 return XFS_ITEM_PINNED;
609         }
610
611 #ifdef DEBUG
612         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
613                 ASSERT(iip->ili_format.ilf_fields != 0);
614                 ASSERT(iip->ili_logged == 0);
615                 ASSERT(lip->li_flags & XFS_LI_IN_AIL);
616         }
617 #endif
618         return XFS_ITEM_SUCCESS;
619 }
620
621 /*
622  * Unlock the inode associated with the inode log item.
623  * Clear the fields of the inode and inode log item that
624  * are specific to the current transaction.  If the
625  * hold flags is set, do not unlock the inode.
626  */
627 STATIC void
628 xfs_inode_item_unlock(
629         struct xfs_log_item     *lip)
630 {
631         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
632         struct xfs_inode        *ip = iip->ili_inode;
633         unsigned short          lock_flags;
634
635         ASSERT(ip->i_itemp != NULL);
636         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
637
638         /*
639          * If the inode needed a separate buffer with which to log
640          * its extents, then free it now.
641          */
642         if (iip->ili_extents_buf != NULL) {
643                 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS);
644                 ASSERT(ip->i_d.di_nextents > 0);
645                 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_DEXT);
646                 ASSERT(ip->i_df.if_bytes > 0);
647                 kmem_free(iip->ili_extents_buf);
648                 iip->ili_extents_buf = NULL;
649         }
650         if (iip->ili_aextents_buf != NULL) {
651                 ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS);
652                 ASSERT(ip->i_d.di_anextents > 0);
653                 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_AEXT);
654                 ASSERT(ip->i_afp->if_bytes > 0);
655                 kmem_free(iip->ili_aextents_buf);
656                 iip->ili_aextents_buf = NULL;
657         }
658
659         lock_flags = iip->ili_lock_flags;
660         iip->ili_lock_flags = 0;
661         if (lock_flags) {
662                 xfs_iunlock(ip, lock_flags);
663                 IRELE(ip);
664         }
665 }
666
667 /*
668  * This is called to find out where the oldest active copy of the inode log
669  * item in the on disk log resides now that the last log write of it completed
670  * at the given lsn.  Since we always re-log all dirty data in an inode, the
671  * latest copy in the on disk log is the only one that matters.  Therefore,
672  * simply return the given lsn.
673  *
674  * If the inode has been marked stale because the cluster is being freed, we
675  * don't want to (re-)insert this inode into the AIL. There is a race condition
676  * where the cluster buffer may be unpinned before the inode is inserted into
677  * the AIL during transaction committed processing. If the buffer is unpinned
678  * before the inode item has been committed and inserted, then it is possible
679  * for the buffer to be written and IO completes before the inode is inserted
680  * into the AIL. In that case, we'd be inserting a clean, stale inode into the
681  * AIL which will never get removed. It will, however, get reclaimed which
682  * triggers an assert in xfs_inode_free() complaining about freein an inode
683  * still in the AIL.
684  *
685  * To avoid this, just unpin the inode directly and return a LSN of -1 so the
686  * transaction committed code knows that it does not need to do any further
687  * processing on the item.
688  */
689 STATIC xfs_lsn_t
690 xfs_inode_item_committed(
691         struct xfs_log_item     *lip,
692         xfs_lsn_t               lsn)
693 {
694         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
695         struct xfs_inode        *ip = iip->ili_inode;
696
697         if (xfs_iflags_test(ip, XFS_ISTALE)) {
698                 xfs_inode_item_unpin(lip, 0);
699                 return -1;
700         }
701         return lsn;
702 }
703
704 /*
705  * This gets called by xfs_trans_push_ail(), when IOP_TRYLOCK
706  * failed to get the inode flush lock but did get the inode locked SHARED.
707  * Here we're trying to see if the inode buffer is incore, and if so whether it's
708  * marked delayed write. If that's the case, we'll promote it and that will
709  * allow the caller to write the buffer by triggering the xfsbufd to run.
710  */
711 STATIC void
712 xfs_inode_item_pushbuf(
713         struct xfs_log_item     *lip)
714 {
715         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
716         struct xfs_inode        *ip = iip->ili_inode;
717         struct xfs_buf          *bp;
718
719         ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED));
720
721         /*
722          * If a flush is not in progress anymore, chances are that the
723          * inode was taken off the AIL. So, just get out.
724          */
725         if (completion_done(&ip->i_flush) ||
726             !(lip->li_flags & XFS_LI_IN_AIL)) {
727                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
728                 return;
729         }
730
731         bp = xfs_incore(ip->i_mount->m_ddev_targp, iip->ili_format.ilf_blkno,
732                         iip->ili_format.ilf_len, XBF_TRYLOCK);
733
734         xfs_iunlock(ip, XFS_ILOCK_SHARED);
735         if (!bp)
736                 return;
737         if (XFS_BUF_ISDELAYWRITE(bp))
738                 xfs_buf_delwri_promote(bp);
739         xfs_buf_relse(bp);
740 }
741
742 /*
743  * This is called to asynchronously write the inode associated with this
744  * inode log item out to disk. The inode will already have been locked by
745  * a successful call to xfs_inode_item_trylock().
746  */
747 STATIC void
748 xfs_inode_item_push(
749         struct xfs_log_item     *lip)
750 {
751         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
752         struct xfs_inode        *ip = iip->ili_inode;
753
754         ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED));
755         ASSERT(!completion_done(&ip->i_flush));
756
757         /*
758          * Since we were able to lock the inode's flush lock and
759          * we found it on the AIL, the inode must be dirty.  This
760          * is because the inode is removed from the AIL while still
761          * holding the flush lock in xfs_iflush_done().  Thus, if
762          * we found it in the AIL and were able to obtain the flush
763          * lock without sleeping, then there must not have been
764          * anyone in the process of flushing the inode.
765          */
766         ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) ||
767                iip->ili_format.ilf_fields != 0);
768
769         /*
770          * Push the inode to it's backing buffer. This will not remove the
771          * inode from the AIL - a further push will be required to trigger a
772          * buffer push. However, this allows all the dirty inodes to be pushed
773          * to the buffer before it is pushed to disk. The buffer IO completion
774          * will pull the inode from the AIL, mark it clean and unlock the flush
775          * lock.
776          */
777         (void) xfs_iflush(ip, SYNC_TRYLOCK);
778         xfs_iunlock(ip, XFS_ILOCK_SHARED);
779 }
780
781 /*
782  * XXX rcc - this one really has to do something.  Probably needs
783  * to stamp in a new field in the incore inode.
784  */
785 STATIC void
786 xfs_inode_item_committing(
787         struct xfs_log_item     *lip,
788         xfs_lsn_t               lsn)
789 {
790         INODE_ITEM(lip)->ili_last_lsn = lsn;
791 }
792
793 /*
794  * This is the ops vector shared by all buf log items.
795  */
796 static struct xfs_item_ops xfs_inode_item_ops = {
797         .iop_size       = xfs_inode_item_size,
798         .iop_format     = xfs_inode_item_format,
799         .iop_pin        = xfs_inode_item_pin,
800         .iop_unpin      = xfs_inode_item_unpin,
801         .iop_trylock    = xfs_inode_item_trylock,
802         .iop_unlock     = xfs_inode_item_unlock,
803         .iop_committed  = xfs_inode_item_committed,
804         .iop_push       = xfs_inode_item_push,
805         .iop_pushbuf    = xfs_inode_item_pushbuf,
806         .iop_committing = xfs_inode_item_committing
807 };
808
809
810 /*
811  * Initialize the inode log item for a newly allocated (in-core) inode.
812  */
813 void
814 xfs_inode_item_init(
815         struct xfs_inode        *ip,
816         struct xfs_mount        *mp)
817 {
818         struct xfs_inode_log_item *iip;
819
820         ASSERT(ip->i_itemp == NULL);
821         iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP);
822
823         iip->ili_inode = ip;
824         xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
825                                                 &xfs_inode_item_ops);
826         iip->ili_format.ilf_type = XFS_LI_INODE;
827         iip->ili_format.ilf_ino = ip->i_ino;
828         iip->ili_format.ilf_blkno = ip->i_imap.im_blkno;
829         iip->ili_format.ilf_len = ip->i_imap.im_len;
830         iip->ili_format.ilf_boffset = ip->i_imap.im_boffset;
831 }
832
833 /*
834  * Free the inode log item and any memory hanging off of it.
835  */
836 void
837 xfs_inode_item_destroy(
838         xfs_inode_t     *ip)
839 {
840 #ifdef XFS_TRANS_DEBUG
841         if (ip->i_itemp->ili_root_size != 0) {
842                 kmem_free(ip->i_itemp->ili_orig_root);
843         }
844 #endif
845         kmem_zone_free(xfs_ili_zone, ip->i_itemp);
846 }
847
848
849 /*
850  * This is the inode flushing I/O completion routine.  It is called
851  * from interrupt level when the buffer containing the inode is
852  * flushed to disk.  It is responsible for removing the inode item
853  * from the AIL if it has not been re-logged, and unlocking the inode's
854  * flush lock.
855  *
856  * To reduce AIL lock traffic as much as possible, we scan the buffer log item
857  * list for other inodes that will run this function. We remove them from the
858  * buffer list so we can process all the inode IO completions in one AIL lock
859  * traversal.
860  */
861 void
862 xfs_iflush_done(
863         struct xfs_buf          *bp,
864         struct xfs_log_item     *lip)
865 {
866         struct xfs_inode_log_item *iip;
867         struct xfs_log_item     *blip;
868         struct xfs_log_item     *next;
869         struct xfs_log_item     *prev;
870         struct xfs_ail          *ailp = lip->li_ailp;
871         int                     need_ail = 0;
872
873         /*
874          * Scan the buffer IO completions for other inodes being completed and
875          * attach them to the current inode log item.
876          */
877         blip = bp->b_fspriv;
878         prev = NULL;
879         while (blip != NULL) {
880                 if (lip->li_cb != xfs_iflush_done) {
881                         prev = blip;
882                         blip = blip->li_bio_list;
883                         continue;
884                 }
885
886                 /* remove from list */
887                 next = blip->li_bio_list;
888                 if (!prev) {
889                         bp->b_fspriv = next;
890                 } else {
891                         prev->li_bio_list = next;
892                 }
893
894                 /* add to current list */
895                 blip->li_bio_list = lip->li_bio_list;
896                 lip->li_bio_list = blip;
897
898                 /*
899                  * while we have the item, do the unlocked check for needing
900                  * the AIL lock.
901                  */
902                 iip = INODE_ITEM(blip);
903                 if (iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn)
904                         need_ail++;
905
906                 blip = next;
907         }
908
909         /* make sure we capture the state of the initial inode. */
910         iip = INODE_ITEM(lip);
911         if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn)
912                 need_ail++;
913
914         /*
915          * We only want to pull the item from the AIL if it is
916          * actually there and its location in the log has not
917          * changed since we started the flush.  Thus, we only bother
918          * if the ili_logged flag is set and the inode's lsn has not
919          * changed.  First we check the lsn outside
920          * the lock since it's cheaper, and then we recheck while
921          * holding the lock before removing the inode from the AIL.
922          */
923         if (need_ail) {
924                 struct xfs_log_item *log_items[need_ail];
925                 int i = 0;
926                 spin_lock(&ailp->xa_lock);
927                 for (blip = lip; blip; blip = blip->li_bio_list) {
928                         iip = INODE_ITEM(blip);
929                         if (iip->ili_logged &&
930                             blip->li_lsn == iip->ili_flush_lsn) {
931                                 log_items[i++] = blip;
932                         }
933                         ASSERT(i <= need_ail);
934                 }
935                 /* xfs_trans_ail_delete_bulk() drops the AIL lock. */
936                 xfs_trans_ail_delete_bulk(ailp, log_items, i);
937         }
938
939
940         /*
941          * clean up and unlock the flush lock now we are done. We can clear the
942          * ili_last_fields bits now that we know that the data corresponding to
943          * them is safely on disk.
944          */
945         for (blip = lip; blip; blip = next) {
946                 next = blip->li_bio_list;
947                 blip->li_bio_list = NULL;
948
949                 iip = INODE_ITEM(blip);
950                 iip->ili_logged = 0;
951                 iip->ili_last_fields = 0;
952                 xfs_ifunlock(iip->ili_inode);
953         }
954 }
955
956 /*
957  * This is the inode flushing abort routine.  It is called
958  * from xfs_iflush when the filesystem is shutting down to clean
959  * up the inode state.
960  * It is responsible for removing the inode item
961  * from the AIL if it has not been re-logged, and unlocking the inode's
962  * flush lock.
963  */
964 void
965 xfs_iflush_abort(
966         xfs_inode_t             *ip)
967 {
968         xfs_inode_log_item_t    *iip = ip->i_itemp;
969
970         if (iip) {
971                 struct xfs_ail  *ailp = iip->ili_item.li_ailp;
972                 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
973                         spin_lock(&ailp->xa_lock);
974                         if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
975                                 /* xfs_trans_ail_delete() drops the AIL lock. */
976                                 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)iip);
977                         } else
978                                 spin_unlock(&ailp->xa_lock);
979                 }
980                 iip->ili_logged = 0;
981                 /*
982                  * Clear the ili_last_fields bits now that we know that the
983                  * data corresponding to them is safely on disk.
984                  */
985                 iip->ili_last_fields = 0;
986                 /*
987                  * Clear the inode logging fields so no more flushes are
988                  * attempted.
989                  */
990                 iip->ili_format.ilf_fields = 0;
991         }
992         /*
993          * Release the inode's flush lock since we're done with it.
994          */
995         xfs_ifunlock(ip);
996 }
997
998 void
999 xfs_istale_done(
1000         struct xfs_buf          *bp,
1001         struct xfs_log_item     *lip)
1002 {
1003         xfs_iflush_abort(INODE_ITEM(lip)->ili_inode);
1004 }
1005
1006 /*
1007  * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
1008  * (which can have different field alignments) to the native version
1009  */
1010 int
1011 xfs_inode_item_format_convert(
1012         xfs_log_iovec_t         *buf,
1013         xfs_inode_log_format_t  *in_f)
1014 {
1015         if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
1016                 xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
1017
1018                 in_f->ilf_type = in_f32->ilf_type;
1019                 in_f->ilf_size = in_f32->ilf_size;
1020                 in_f->ilf_fields = in_f32->ilf_fields;
1021                 in_f->ilf_asize = in_f32->ilf_asize;
1022                 in_f->ilf_dsize = in_f32->ilf_dsize;
1023                 in_f->ilf_ino = in_f32->ilf_ino;
1024                 /* copy biggest field of ilf_u */
1025                 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
1026                        in_f32->ilf_u.ilfu_uuid.__u_bits,
1027                        sizeof(uuid_t));
1028                 in_f->ilf_blkno = in_f32->ilf_blkno;
1029                 in_f->ilf_len = in_f32->ilf_len;
1030                 in_f->ilf_boffset = in_f32->ilf_boffset;
1031                 return 0;
1032         } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
1033                 xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
1034
1035                 in_f->ilf_type = in_f64->ilf_type;
1036                 in_f->ilf_size = in_f64->ilf_size;
1037                 in_f->ilf_fields = in_f64->ilf_fields;
1038                 in_f->ilf_asize = in_f64->ilf_asize;
1039                 in_f->ilf_dsize = in_f64->ilf_dsize;
1040                 in_f->ilf_ino = in_f64->ilf_ino;
1041                 /* copy biggest field of ilf_u */
1042                 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
1043                        in_f64->ilf_u.ilfu_uuid.__u_bits,
1044                        sizeof(uuid_t));
1045                 in_f->ilf_blkno = in_f64->ilf_blkno;
1046                 in_f->ilf_len = in_f64->ilf_len;
1047                 in_f->ilf_boffset = in_f64->ilf_boffset;
1048                 return 0;
1049         }
1050         return EFSCORRUPTED;
1051 }