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

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

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

~ [ 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