~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_inode_item.c

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  3  * All Rights Reserved.
  4  *
  5  * This program is free software; you can redistribute it and/or
  6  * modify it under the terms of the GNU General Public License as
  7  * published by the Free Software Foundation.
  8  *
  9  * This program is distributed in the hope that it would be useful,
 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  * GNU General Public License for more details.
 13  *
 14  * You should have received a copy of the GNU General Public License
 15  * along with this program; if not, write the Free Software Foundation,
 16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 17  */
 18 #include "xfs.h"
 19 #include "xfs_fs.h"
 20 #include "xfs_format.h"
 21 #include "xfs_log_format.h"
 22 #include "xfs_trans_resv.h"
 23 #include "xfs_mount.h"
 24 #include "xfs_inode.h"
 25 #include "xfs_trans.h"
 26 #include "xfs_inode_item.h"
 27 #include "xfs_error.h"
 28 #include "xfs_trace.h"
 29 #include "xfs_trans_priv.h"
 30 #include "xfs_log.h"
 31 
 32 
 33 kmem_zone_t     *xfs_ili_zone;          /* inode log item zone */
 34 
 35 static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
 36 {
 37         return container_of(lip, struct xfs_inode_log_item, ili_item);
 38 }
 39 
 40 STATIC void
 41 xfs_inode_item_data_fork_size(
 42         struct xfs_inode_log_item *iip,
 43         int                     *nvecs,
 44         int                     *nbytes)
 45 {
 46         struct xfs_inode        *ip = iip->ili_inode;
 47 
 48         switch (ip->i_d.di_format) {
 49         case XFS_DINODE_FMT_EXTENTS:
 50                 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
 51                     ip->i_d.di_nextents > 0 &&
 52                     ip->i_df.if_bytes > 0) {
 53                         /* worst case, doesn't subtract delalloc extents */
 54                         *nbytes += XFS_IFORK_DSIZE(ip);
 55                         *nvecs += 1;
 56                 }
 57                 break;
 58         case XFS_DINODE_FMT_BTREE:
 59                 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
 60                     ip->i_df.if_broot_bytes > 0) {
 61                         *nbytes += ip->i_df.if_broot_bytes;
 62                         *nvecs += 1;
 63                 }
 64                 break;
 65         case XFS_DINODE_FMT_LOCAL:
 66                 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
 67                     ip->i_df.if_bytes > 0) {
 68                         *nbytes += roundup(ip->i_df.if_bytes, 4);
 69                         *nvecs += 1;
 70                 }
 71                 break;
 72 
 73         case XFS_DINODE_FMT_DEV:
 74         case XFS_DINODE_FMT_UUID:
 75                 break;
 76         default:
 77                 ASSERT(0);
 78                 break;
 79         }
 80 }
 81 
 82 STATIC void
 83 xfs_inode_item_attr_fork_size(
 84         struct xfs_inode_log_item *iip,
 85         int                     *nvecs,
 86         int                     *nbytes)
 87 {
 88         struct xfs_inode        *ip = iip->ili_inode;
 89 
 90         switch (ip->i_d.di_aformat) {
 91         case XFS_DINODE_FMT_EXTENTS:
 92                 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
 93                     ip->i_d.di_anextents > 0 &&
 94                     ip->i_afp->if_bytes > 0) {
 95                         /* worst case, doesn't subtract unused space */
 96                         *nbytes += XFS_IFORK_ASIZE(ip);
 97                         *nvecs += 1;
 98                 }
 99                 break;
100         case XFS_DINODE_FMT_BTREE:
101                 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
102                     ip->i_afp->if_broot_bytes > 0) {
103                         *nbytes += ip->i_afp->if_broot_bytes;
104                         *nvecs += 1;
105                 }
106                 break;
107         case XFS_DINODE_FMT_LOCAL:
108                 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
109                     ip->i_afp->if_bytes > 0) {
110                         *nbytes += roundup(ip->i_afp->if_bytes, 4);
111                         *nvecs += 1;
112                 }
113                 break;
114         default:
115                 ASSERT(0);
116                 break;
117         }
118 }
119 
120 /*
121  * This returns the number of iovecs needed to log the given inode item.
122  *
123  * We need one iovec for the inode log format structure, one for the
124  * inode core, and possibly one for the inode data/extents/b-tree root
125  * and one for the inode attribute data/extents/b-tree root.
126  */
127 STATIC void
128 xfs_inode_item_size(
129         struct xfs_log_item     *lip,
130         int                     *nvecs,
131         int                     *nbytes)
132 {
133         struct xfs_inode_log_item *iip = INODE_ITEM(lip);
134         struct xfs_inode        *ip = iip->ili_inode;
135 
136         *nvecs += 2;
137         *nbytes += sizeof(struct xfs_inode_log_format) +
138                    xfs_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
146 xfs_inode_item_format_data_fork(
147         struct xfs_inode_log_item *iip,
148         struct xfs_inode_log_format *ilf,
149         struct xfs_log_vec      *lv,
150         struct xfs_log_iovec    **vecp)
151 {
152         struct xfs_inode        *ip = iip->ili_inode;
153         size_t                  data_bytes;
154 
155         switch (ip->i_d.di_format) {
156         case XFS_DINODE_FMT_EXTENTS:
157                 iip->ili_fields &=
158                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
159                           XFS_ILOG_DEV | XFS_ILOG_UUID);
160 
161                 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
162                     ip->i_d.di_nextents > 0 &&
163                     ip->i_df.if_bytes > 0) {
164                         struct xfs_bmbt_rec *p;
165 
166                         ASSERT(ip->i_df.if_u1.if_extents != NULL);
167                         ASSERT(ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) > 0);
168 
169                         p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
170                         data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
171                         xlog_finish_iovec(lv, *vecp, data_bytes);
172 
173                         ASSERT(data_bytes <= ip->i_df.if_bytes);
174 
175                         ilf->ilf_dsize = data_bytes;
176                         ilf->ilf_size++;
177                 } else {
178                         iip->ili_fields &= ~XFS_ILOG_DEXT;
179                 }
180                 break;
181         case XFS_DINODE_FMT_BTREE:
182                 iip->ili_fields &=
183                         ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
184                           XFS_ILOG_DEV | XFS_ILOG_UUID);
185 
186                 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
187                     ip->i_df.if_broot_bytes > 0) {
188                         ASSERT(ip->i_df.if_broot != NULL);
189                         xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
190                                         ip->i_df.if_broot,
191                                         ip->i_df.if_broot_bytes);
192                         ilf->ilf_dsize = ip->i_df.if_broot_bytes;
193                         ilf->ilf_size++;
194                 } else {
195                         ASSERT(!(iip->ili_fields &
196                                  XFS_ILOG_DBROOT));
197                         iip->ili_fields &= ~XFS_ILOG_DBROOT;
198                 }
199                 break;
200         case XFS_DINODE_FMT_LOCAL:
201                 iip->ili_fields &=
202                         ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
203                           XFS_ILOG_DEV | XFS_ILOG_UUID);
204                 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
205                     ip->i_df.if_bytes > 0) {
206                         /*
207                          * Round i_bytes up to a word boundary.
208                          * The underlying memory is guaranteed to
209                          * to be there by xfs_idata_realloc().
210                          */
211                         data_bytes = roundup(ip->i_df.if_bytes, 4);
212                         ASSERT(ip->i_df.if_real_bytes == 0 ||
213                                ip->i_df.if_real_bytes == data_bytes);
214                         ASSERT(ip->i_df.if_u1.if_data != NULL);
215                         ASSERT(ip->i_d.di_size > 0);
216                         xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
217                                         ip->i_df.if_u1.if_data, data_bytes);
218                         ilf->ilf_dsize = (unsigned)data_bytes;
219                         ilf->ilf_size++;
220                 } else {
221                         iip->ili_fields &= ~XFS_ILOG_DDATA;
222                 }
223                 break;
224         case XFS_DINODE_FMT_DEV:
225                 iip->ili_fields &=
226                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
227                           XFS_ILOG_DEXT | XFS_ILOG_UUID);
228                 if (iip->ili_fields & XFS_ILOG_DEV)
229                         ilf->ilf_u.ilfu_rdev = ip->i_df.if_u2.if_rdev;
230                 break;
231         case XFS_DINODE_FMT_UUID:
232                 iip->ili_fields &=
233                         ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
234                           XFS_ILOG_DEXT | XFS_ILOG_DEV);
235                 if (iip->ili_fields & XFS_ILOG_UUID)
236                         ilf->ilf_u.ilfu_uuid = ip->i_df.if_u2.if_uuid;
237                 break;
238         default:
239                 ASSERT(0);
240                 break;
241         }
242 }
243 
244 STATIC void
245 xfs_inode_item_format_attr_fork(
246         struct xfs_inode_log_item *iip,
247         struct xfs_inode_log_format *ilf,
248         struct xfs_log_vec      *lv,
249         struct xfs_log_iovec    **vecp)
250 {
251         struct xfs_inode        *ip = iip->ili_inode;
252         size_t                  data_bytes;
253 
254         switch (ip->i_d.di_aformat) {
255         case XFS_DINODE_FMT_EXTENTS:
256                 iip->ili_fields &=
257                         ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
258 
259                 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
260                     ip->i_d.di_anextents > 0 &&
261                     ip->i_afp->if_bytes > 0) {
262                         struct xfs_bmbt_rec *p;
263 
264                         ASSERT(ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) ==
265                                 ip->i_d.di_anextents);
266                         ASSERT(ip->i_afp->if_u1.if_extents != NULL);
267 
268                         p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
269                         data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
270                         xlog_finish_iovec(lv, *vecp, data_bytes);
271 
272                         ilf->ilf_asize = data_bytes;
273                         ilf->ilf_size++;
274                 } else {
275                         iip->ili_fields &= ~XFS_ILOG_AEXT;
276                 }
277                 break;
278         case XFS_DINODE_FMT_BTREE:
279                 iip->ili_fields &=
280                         ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
281 
282                 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
283                     ip->i_afp->if_broot_bytes > 0) {
284                         ASSERT(ip->i_afp->if_broot != NULL);
285 
286                         xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
287                                         ip->i_afp->if_broot,
288                                         ip->i_afp->if_broot_bytes);
289                         ilf->ilf_asize = ip->i_afp->if_broot_bytes;
290                         ilf->ilf_size++;
291                 } else {
292                         iip->ili_fields &= ~XFS_ILOG_ABROOT;
293                 }
294                 break;
295         case XFS_DINODE_FMT_LOCAL:
296                 iip->ili_fields &=
297                         ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
298 
299                 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
300                     ip->i_afp->if_bytes > 0) {
301                         /*
302                          * Round i_bytes up to a word boundary.
303                          * The underlying memory is guaranteed to
304                          * to be there by xfs_idata_realloc().
305                          */
306                         data_bytes = roundup(ip->i_afp->if_bytes, 4);
307                         ASSERT(ip->i_afp->if_real_bytes == 0 ||
308                                ip->i_afp->if_real_bytes == data_bytes);
309                         ASSERT(ip->i_afp->if_u1.if_data != NULL);
310                         xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
311                                         ip->i_afp->if_u1.if_data,
312                                         data_bytes);
313                         ilf->ilf_asize = (unsigned)data_bytes;
314                         ilf->ilf_size++;
315                 } else {
316                         iip->ili_fields &= ~XFS_ILOG_ADATA;
317                 }
318                 break;
319         default:
320                 ASSERT(0);
321                 break;
322         }
323 }
324 
325 /*
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
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
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
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
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
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
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
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
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
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
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
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                 struct xfs_ail  *ailp = iip->ili_item.li_ailp;
707                 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
708                         spin_lock(&ailp->xa_lock);
709                         if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
710                                 /* xfs_trans_ail_delete() drops the AIL lock. */
711                                 xfs_trans_ail_delete(ailp, &iip->ili_item,
712                                                 stale ?
713                                                      SHUTDOWN_LOG_IO_ERROR :
714                                                      SHUTDOWN_CORRUPT_INCORE);
715                         } else
716                                 spin_unlock(&ailp->xa_lock);
717                 }
718                 iip->ili_logged = 0;
719                 /*
720                  * Clear the ili_last_fields bits now that we know that the
721                  * data corresponding to them is safely on disk.
722                  */
723                 iip->ili_last_fields = 0;
724                 /*
725                  * Clear the inode logging fields so no more flushes are
726                  * attempted.
727                  */
728                 iip->ili_fields = 0;
729         }
730         /*
731          * Release the inode's flush lock since we're done with it.
732          */
733         xfs_ifunlock(ip);
734 }
735 
736 void
737 xfs_istale_done(
738         struct xfs_buf          *bp,
739         struct xfs_log_item     *lip)
740 {
741         xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
742 }
743 
744 /*
745  * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
746  * (which can have different field alignments) to the native version
747  */
748 int
749 xfs_inode_item_format_convert(
750         xfs_log_iovec_t         *buf,
751         xfs_inode_log_format_t  *in_f)
752 {
753         if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
754                 xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
755 
756                 in_f->ilf_type = in_f32->ilf_type;
757                 in_f->ilf_size = in_f32->ilf_size;
758                 in_f->ilf_fields = in_f32->ilf_fields;
759                 in_f->ilf_asize = in_f32->ilf_asize;
760                 in_f->ilf_dsize = in_f32->ilf_dsize;
761                 in_f->ilf_ino = in_f32->ilf_ino;
762                 /* copy biggest field of ilf_u */
763                 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
764                        in_f32->ilf_u.ilfu_uuid.__u_bits,
765                        sizeof(uuid_t));
766                 in_f->ilf_blkno = in_f32->ilf_blkno;
767                 in_f->ilf_len = in_f32->ilf_len;
768                 in_f->ilf_boffset = in_f32->ilf_boffset;
769                 return 0;
770         } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
771                 xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
772 
773                 in_f->ilf_type = in_f64->ilf_type;
774                 in_f->ilf_size = in_f64->ilf_size;
775                 in_f->ilf_fields = in_f64->ilf_fields;
776                 in_f->ilf_asize = in_f64->ilf_asize;
777                 in_f->ilf_dsize = in_f64->ilf_dsize;
778                 in_f->ilf_ino = in_f64->ilf_ino;
779                 /* copy biggest field of ilf_u */
780                 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
781                        in_f64->ilf_u.ilfu_uuid.__u_bits,
782                        sizeof(uuid_t));
783                 in_f->ilf_blkno = in_f64->ilf_blkno;
784                 in_f->ilf_len = in_f64->ilf_len;
785                 in_f->ilf_boffset = in_f64->ilf_boffset;
786                 return 0;
787         }
788         return -EFSCORRUPTED;
789 }
790 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp