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