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