imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,37 +1,37 @@
 inode *xfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation) {
   xfs_mount_t *mp = XFS_M(sb);
   xfs_inode_t *ip;
   int error;
   /*
    * NFS can sometimes send requests for ino 0.  Fail them gracefully.
    */
   if (ino == 0) return ERR_PTR(-ESTALE);
   /*
    * The XFS_IGET_UNTRUSTED means that an invalid inode number is just
    * fine and not an indication of a corrupted filesystem as clients can
    * send invalid file handles and we have to handle it gracefully..
    */
   error = xfs_iget(mp, NULL, ino, XFS_IGET_UNTRUSTED, 0, &ip);
   if (error) {
     /*
      * EINVAL means the inode cluster doesn't exist anymore.
      * EFSCORRUPTED means the metadata pointing to the inode cluster
      * or the inode cluster itself is corrupt.  This implies the
      * filehandle is stale, so we should translate it here.
      * We don't use ESTALE directly down the chain to not
      * confuse applications using bulkstat that expect EINVAL.
      */
     switch (error) {
     case -EINVAL:
     case -ENOENT:
     case -EFSCORRUPTED: error = -ESTALE; break;
     default: break;
     }
     return ERR_PTR(error);
   }
   if (VFS_I(ip)->i_generation != generation) {
-    IRELE(ip);
+    xfs_irele(ip);
     return ERR_PTR(-ESTALE);
   }
   return VFS_I(ip);
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,30 +1,30 @@
 xfs_agnumber_t xfs_filestream_lookup_ag(struct xfs_inode *ip) {
   struct xfs_mount *mp = ip->i_mount;
   struct xfs_inode *pip = NULL;
   xfs_agnumber_t startag, ag = NULLAGNUMBER;
   struct xfs_mru_cache_elem *mru;
   ASSERT(S_ISREG(VFS_I(ip)->i_mode));
   pip = xfs_filestream_get_parent(ip);
   if (!pip) return NULLAGNUMBER;
   mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino);
   if (mru) {
     ag = container_of(mru, struct xfs_fstrm_item, mru)->ag;
     xfs_mru_cache_done(mp->m_filestream);
     trace_xfs_filestream_lookup(mp, ip->i_ino, ag);
     goto out;
   }
   /*
    * Set the starting AG using the rotor for inode32, otherwise
    * use the directory inode's AG.
    */
   if (mp->m_flags & XFS_MOUNT_32BITINODES) {
     xfs_agnumber_t rotorstep = xfs_rotorstep;
     startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
     mp->m_agfrotor = (mp->m_agfrotor + 1) % (mp->m_sb.sb_agcount * rotorstep);
   } else
     startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
   if (xfs_filestream_pick_ag(pip, startag, &ag, 0, 0)) ag = NULLAGNUMBER;
 out:
-  IRELE(pip);
+  xfs_irele(pip);
   return ag;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,28 +1,28 @@
 int xfs_filestream_new_ag(struct xfs_bmalloca *ap, xfs_agnumber_t *agp) {
   struct xfs_inode *ip = ap->ip, *pip;
   struct xfs_mount *mp = ip->i_mount;
   xfs_extlen_t minlen = ap->length;
   xfs_agnumber_t startag = 0;
   int flags = 0;
   int err = 0;
   struct xfs_mru_cache_elem *mru;
   *agp = NULLAGNUMBER;
   pip = xfs_filestream_get_parent(ip);
   if (!pip) goto exit;
   mru = xfs_mru_cache_remove(mp->m_filestream, pip->i_ino);
   if (mru) {
     struct xfs_fstrm_item *item = container_of(mru, struct xfs_fstrm_item, mru);
     startag = (item->ag + 1) % mp->m_sb.sb_agcount;
   }
   if (xfs_alloc_is_userdata(ap->datatype)) flags |= XFS_PICK_USERDATA;
   if (ap->tp->t_dfops->dop_low) flags |= XFS_PICK_LOWSPACE;
   err = xfs_filestream_pick_ag(pip, startag, agp, flags, minlen);
   /*
    * Only free the item here so we skip over the old AG earlier.
    */
   if (mru) xfs_fstrm_free_func(mp, mru);
-  IRELE(pip);
+  xfs_irele(pip);
 exit:
   if (*agp == NULLAGNUMBER) *agp = 0;
   return err;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,9 +1,9 @@
 int xfs_icache_inode_is_allocated(struct xfs_mount *mp, struct xfs_trans *tp, xfs_ino_t ino, bool *inuse) {
   struct xfs_inode *ip;
   int error;
   error = xfs_iget(mp, tp, ino, XFS_IGET_INCORE, 0, &ip);
   if (error) return error;
   *inuse = !!(VFS_I(ip)->i_mode);
-  IRELE(ip);
+  xfs_irele(ip);
   return 0;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,70 +1,70 @@
 STATIC int xfs_inode_ag_walk(struct xfs_mount *mp, struct xfs_perag *pag, int (*execute)(struct xfs_inode *ip, int flags, void *args), int flags, void *args, int tag, int iter_flags) {
   uint32_t first_index;
   int last_error = 0;
   int skipped;
   int done;
   int nr_found;
 restart:
   done = 0;
   skipped = 0;
   first_index = 0;
   nr_found = 0;
   do {
     struct xfs_inode *batch[XFS_LOOKUP_BATCH];
     int error = 0;
     int i;
     rcu_read_lock();
     if (tag == -1)
       nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void **)batch, first_index, XFS_LOOKUP_BATCH);
     else
       nr_found = radix_tree_gang_lookup_tag(&pag->pag_ici_root, (void **)batch, first_index, XFS_LOOKUP_BATCH, tag);
     if (!nr_found) {
       rcu_read_unlock();
       break;
     }
     /*
      * Grab the inodes before we drop the lock. if we found
      * nothing, nr == 0 and the loop will be skipped.
      */
     for (i = 0; i < nr_found; i++) {
       struct xfs_inode *ip = batch[i];
       if (done || xfs_inode_ag_walk_grab(ip, iter_flags)) batch[i] = NULL;
       /*
        * Update the index for the next lookup. Catch
        * overflows into the next AG range which can occur if
        * we have inodes in the last block of the AG and we
        * are currently pointing to the last inode.
        *
        * Because we may see inodes that are from the wrong AG
        * due to RCU freeing and reallocation, only update the
        * index if it lies in this AG. It was a race that lead
        * us to see this inode, so another lookup from the
        * same index will not find it again.
        */
       if (XFS_INO_TO_AGNO(mp, ip->i_ino) != pag->pag_agno) continue;
       first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
       if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino)) done = 1;
     }
     /* unlock now we've grabbed the inodes. */
     rcu_read_unlock();
     for (i = 0; i < nr_found; i++) {
       if (!batch[i]) continue;
       if ((iter_flags & XFS_AGITER_INEW_WAIT) && xfs_iflags_test(batch[i], XFS_INEW)) xfs_inew_wait(batch[i]);
       error = execute(batch[i], flags, args);
-      IRELE(batch[i]);
+      xfs_irele(batch[i]);
       if (error == -EAGAIN) {
         skipped++;
         continue;
       }
       if (error && last_error != -EFSCORRUPTED) last_error = error;
     }
     /* bail out if the filesystem is corrupted.  */
     if (error == -EFSCORRUPTED) break;
     cond_resched();
   } while (nr_found && !done);
   if (skipped) {
     delay(1);
     goto restart;
   }
   return last_error;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,59 +1,59 @@
 int xfs_create_tmpfile(struct xfs_inode *dp, umode_t mode, struct xfs_inode **ipp) {
   struct xfs_mount *mp = dp->i_mount;
   struct xfs_inode *ip = NULL;
   struct xfs_trans *tp = NULL;
   int error;
   prid_t prid;
   struct xfs_dquot *udqp = NULL;
   struct xfs_dquot *gdqp = NULL;
   struct xfs_dquot *pdqp = NULL;
   struct xfs_trans_res *tres;
   uint resblks;
   if (XFS_FORCED_SHUTDOWN(mp)) return -EIO;
   prid = xfs_get_initial_prid(dp);
   /*
    * Make sure that we have allocated dquot(s) on disk.
    */
   error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()), xfs_kgid_to_gid(current_fsgid()), prid, XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp, &pdqp);
   if (error) return error;
   resblks = XFS_IALLOC_SPACE_RES(mp);
   tres = &M_RES(mp)->tr_create_tmpfile;
   error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
   if (error) goto out_release_inode;
   error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, pdqp, resblks, 1, 0);
   if (error) goto out_trans_cancel;
   error = xfs_dir_ialloc(&tp, dp, mode, 1, 0, prid, &ip);
   if (error) goto out_trans_cancel;
   if (mp->m_flags & XFS_MOUNT_WSYNC) xfs_trans_set_sync(tp);
   /*
    * Attach the dquot(s) to the inodes and modify them incore.
    * These ids of the inode couldn't have changed since the new
    * inode has been locked ever since it was created.
    */
   xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
   error = xfs_iunlink(tp, ip);
   if (error) goto out_trans_cancel;
   error = xfs_trans_commit(tp);
   if (error) goto out_release_inode;
   xfs_qm_dqrele(udqp);
   xfs_qm_dqrele(gdqp);
   xfs_qm_dqrele(pdqp);
   *ipp = ip;
   return 0;
 out_trans_cancel:
   xfs_trans_cancel(tp);
 out_release_inode:
   /*
    * Wait until after the current transaction is aborted to finish the
    * setup of the inode and release the inode.  This prevents recursive
    * transactions and deadlocks from xfs_inactive.
    */
   if (ip) {
     xfs_finish_inode_setup(ip);
-    IRELE(ip);
+    xfs_irele(ip);
   }
   xfs_qm_dqrele(udqp);
   xfs_qm_dqrele(gdqp);
   xfs_qm_dqrele(pdqp);
   return error;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,56 +1,56 @@
 STATIC int xfs_generic_create(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev, bool tmpfile) /* unnamed file */
 {
   struct inode *inode;
   struct xfs_inode *ip = NULL;
   struct posix_acl *default_acl, *acl;
   struct xfs_name name;
   int error;
   /*
    * Irix uses Missed'em'V split, but doesn't want to see
    * the upper 5 bits of (14bit) major.
    */
   if (S_ISCHR(mode) || S_ISBLK(mode)) {
     if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff)) return -EINVAL;
   } else {
     rdev = 0;
   }
   error = posix_acl_create(dir, &mode, &default_acl, &acl);
   if (error) return error;
   /* Verify mode is valid also for tmpfile case */
   error = xfs_dentry_mode_to_name(&name, dentry, mode);
   if (unlikely(error)) goto out_free_acl;
   if (!tmpfile) {
     error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
   } else {
     error = xfs_create_tmpfile(XFS_I(dir), mode, &ip);
   }
   if (unlikely(error)) goto out_free_acl;
   inode = VFS_I(ip);
   error = xfs_init_security(inode, dir, &dentry->d_name);
   if (unlikely(error)) goto out_cleanup_inode;
 #ifdef CONFIG_XFS_POSIX_ACL
   if (default_acl) {
     error = __xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
     if (error) goto out_cleanup_inode;
   }
   if (acl) {
     error = __xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
     if (error) goto out_cleanup_inode;
   }
 #endif
   xfs_setup_iops(ip);
   if (tmpfile)
     d_tmpfile(dentry, inode);
   else
     d_instantiate(dentry, inode);
   xfs_finish_inode_setup(ip);
 out_free_acl:
   if (default_acl) posix_acl_release(default_acl);
   if (acl) posix_acl_release(acl);
   return error;
 out_cleanup_inode:
   xfs_finish_inode_setup(ip);
   if (!tmpfile) xfs_cleanup_inode(dir, inode, dentry);
-  iput(inode);
+  xfs_irele(ip);
   goto out_free_acl;
 }<sep>@@
expression e,e1,inode;
@@
   inode = VFS_I(e);
   ... when != inode = e1;
?- iput(inode);
+  xfs_irele(e);
--- initial
+++ final
@@ -1,25 +1,25 @@
 STATIC int xfs_vn_symlink(struct inode *dir, struct dentry *dentry, const char *symname) {
   struct inode *inode;
   struct xfs_inode *cip = NULL;
   struct xfs_name name;
   int error;
   umode_t mode;
   mode = S_IFLNK | (irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
   error = xfs_dentry_mode_to_name(&name, dentry, mode);
   if (unlikely(error)) goto out;
   error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
   if (unlikely(error)) goto out;
   inode = VFS_I(cip);
   error = xfs_init_security(inode, dir, &dentry->d_name);
   if (unlikely(error)) goto out_cleanup_inode;
   xfs_setup_iops(cip);
   d_instantiate(dentry, inode);
   xfs_finish_inode_setup(cip);
   return 0;
 out_cleanup_inode:
   xfs_finish_inode_setup(cip);
   xfs_cleanup_inode(dir, inode, dentry);
-  iput(inode);
+  xfs_irele(cip);
 out:
   return error;
 }<sep>@@
expression e,e1,inode;
@@
   inode = VFS_I(e);
   ... when != inode = e1;
?- iput(inode);
+  xfs_irele(e);
--- initial
+++ final
@@ -1,41 +1,41 @@
 STATIC xfs_agino_t xlog_recover_process_one_iunlink(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino, int bucket) {
   struct xfs_buf *ibp;
   struct xfs_dinode *dip;
   struct xfs_inode *ip;
   xfs_ino_t ino;
   int error;
   ino = XFS_AGINO_TO_INO(mp, agno, agino);
   error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
   if (error) goto fail;
   /*
    * Get the on disk inode to find the next inode in the bucket.
    */
   error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
   if (error) goto fail_iput;
   xfs_iflags_clear(ip, XFS_IRECOVERY);
   ASSERT(VFS_I(ip)->i_nlink == 0);
   ASSERT(VFS_I(ip)->i_mode != 0);
   /* setup for the next pass */
   agino = be32_to_cpu(dip->di_next_unlinked);
   xfs_buf_relse(ibp);
   /*
    * Prevent any DMAPI event from being sent when the reference on
    * the inode is dropped.
    */
   ip->i_d.di_dmevmask = 0;
-  IRELE(ip);
+  xfs_irele(ip);
   return agino;
 fail_iput:
-  IRELE(ip);
+  xfs_irele(ip);
 fail:
   /*
    * We can't read in the inode this bucket points to, or this inode
    * is messed up.  Just ditch this bucket of inodes.  We will lose
    * some inodes and space, but at least we won't hang.
    *
    * Call xlog_recover_clear_agi_bucket() to perform a transaction to
    * clear the inode pointer in the bucket.
    */
   xlog_recover_clear_agi_bucket(mp, agno, bucket);
   return NULLAGINO;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,31 +1,31 @@
 STATIC int xfs_qm_scall_trunc_qfile(struct xfs_mount *mp, xfs_ino_t ino) {
   struct xfs_inode *ip;
   struct xfs_trans *tp;
   int error;
   if (ino == NULLFSINO) return 0;
   error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
   if (error) return error;
   xfs_ilock(ip, XFS_IOLOCK_EXCL);
   error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
   if (error) {
     xfs_iunlock(ip, XFS_IOLOCK_EXCL);
     goto out_put;
   }
   xfs_ilock(ip, XFS_ILOCK_EXCL);
   xfs_trans_ijoin(tp, ip, 0);
   ip->i_d.di_size = 0;
   xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
   error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
   if (error) {
     xfs_trans_cancel(tp);
     goto out_unlock;
   }
   ASSERT(ip->i_d.di_nextents == 0);
   xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
   error = xfs_trans_commit(tp);
 out_unlock:
   xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
 out_put:
-  IRELE(ip);
+  xfs_irele(ip);
   return error;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,14 +1,14 @@
 STATIC void xfs_qm_destroy_quotainos(xfs_quotainfo_t *qi) {
   if (qi->qi_uquotaip) {
-    IRELE(qi->qi_uquotaip);
+    xfs_irele(qi->qi_uquotaip);
     qi->qi_uquotaip = NULL; /* paranoia */
   }
   if (qi->qi_gquotaip) {
-    IRELE(qi->qi_gquotaip);
+    xfs_irele(qi->qi_gquotaip);
     qi->qi_gquotaip = NULL;
   }
   if (qi->qi_pquotaip) {
-    IRELE(qi->qi_pquotaip);
+    xfs_irele(qi->qi_pquotaip);
     qi->qi_pquotaip = NULL;
   }
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,71 +1,71 @@
 STATIC int xfs_qm_dqusage_adjust(xfs_mount_t *mp,     /* mount point for filesystem */
                                  xfs_ino_t ino,       /* inode number to get data for */
                                  void __user *buffer, /* not used */
                                  int ubsize,          /* not used */
                                  int *ubused,         /* not used */
                                  int *res)            /* result code value */
 {
   xfs_inode_t *ip;
   xfs_qcnt_t nblks;
   xfs_filblks_t rtblks = 0; /* total rt blks */
   int error;
   ASSERT(XFS_IS_QUOTA_RUNNING(mp));
   /*
    * rootino must have its resources accounted for, not so with the quota
    * inodes.
    */
   if (xfs_is_quota_inode(&mp->m_sb, ino)) {
     *res = BULKSTAT_RV_NOTHING;
     return -EINVAL;
   }
   /*
    * We don't _need_ to take the ilock EXCL here because quotacheck runs
    * at mount time and therefore nobody will be racing chown/chproj.
    */
   error = xfs_iget(mp, NULL, ino, XFS_IGET_DONTCACHE, 0, &ip);
   if (error) {
     *res = BULKSTAT_RV_NOTHING;
     return error;
   }
   ASSERT(ip->i_delayed_blks == 0);
   if (XFS_IS_REALTIME_INODE(ip)) {
     struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
     if (!(ifp->if_flags & XFS_IFEXTENTS)) {
       error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
       if (error) goto error0;
     }
     xfs_bmap_count_leaves(ifp, &rtblks);
   }
   nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
   /*
    * Add the (disk blocks and inode) resources occupied by this
    * inode to its dquots. We do this adjustment in the incore dquot,
    * and also copy the changes to its buffer.
    * We don't care about putting these changes in a transaction
    * envelope because if we crash in the middle of a 'quotacheck'
    * we have to start from the beginning anyway.
    * Once we're done, we'll log all the dquot bufs.
    *
    * The *QUOTA_ON checks below may look pretty racy, but quotachecks
    * and quotaoffs don't race. (Quotachecks happen at mount time only).
    */
   if (XFS_IS_UQUOTA_ON(mp)) {
     error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks, rtblks);
     if (error) goto error0;
   }
   if (XFS_IS_GQUOTA_ON(mp)) {
     error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks, rtblks);
     if (error) goto error0;
   }
   if (XFS_IS_PQUOTA_ON(mp)) {
     error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks, rtblks);
     if (error) goto error0;
   }
-  IRELE(ip);
+  xfs_irele(ip);
   *res = BULKSTAT_RV_DIDONE;
   return 0;
 error0:
-  IRELE(ip);
+  xfs_irele(ip);
   *res = BULKSTAT_RV_GIVEUP;
   return error;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,59 +1,59 @@
 STATIC int xfs_qm_init_quotainos(xfs_mount_t *mp) {
   struct xfs_inode *uip = NULL;
   struct xfs_inode *gip = NULL;
   struct xfs_inode *pip = NULL;
   int error;
   uint flags = 0;
   ASSERT(mp->m_quotainfo);
   /*
    * Get the uquota and gquota inodes
    */
   if (xfs_sb_version_hasquota(&mp->m_sb)) {
     if (XFS_IS_UQUOTA_ON(mp) && mp->m_sb.sb_uquotino != NULLFSINO) {
       ASSERT(mp->m_sb.sb_uquotino > 0);
       error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 0, 0, &uip);
       if (error) return error;
     }
     if (XFS_IS_GQUOTA_ON(mp) && mp->m_sb.sb_gquotino != NULLFSINO) {
       ASSERT(mp->m_sb.sb_gquotino > 0);
       error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &gip);
       if (error) goto error_rele;
     }
     if (XFS_IS_PQUOTA_ON(mp) && mp->m_sb.sb_pquotino != NULLFSINO) {
       ASSERT(mp->m_sb.sb_pquotino > 0);
       error = xfs_iget(mp, NULL, mp->m_sb.sb_pquotino, 0, 0, &pip);
       if (error) goto error_rele;
     }
   } else {
     flags |= XFS_QMOPT_SBVERSION;
   }
   /*
    * Create the three inodes, if they don't exist already. The changes
    * made above will get added to a transaction and logged in one of
    * the qino_alloc calls below.  If the device is readonly,
    * temporarily switch to read-write to do this.
    */
   if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
     error = xfs_qm_qino_alloc(mp, &uip, flags | XFS_QMOPT_UQUOTA);
     if (error) goto error_rele;
     flags &= ~XFS_QMOPT_SBVERSION;
   }
   if (XFS_IS_GQUOTA_ON(mp) && gip == NULL) {
     error = xfs_qm_qino_alloc(mp, &gip, flags | XFS_QMOPT_GQUOTA);
     if (error) goto error_rele;
     flags &= ~XFS_QMOPT_SBVERSION;
   }
   if (XFS_IS_PQUOTA_ON(mp) && pip == NULL) {
     error = xfs_qm_qino_alloc(mp, &pip, flags | XFS_QMOPT_PQUOTA);
     if (error) goto error_rele;
   }
   mp->m_quotainfo->qi_uquotaip = uip;
   mp->m_quotainfo->qi_gquotaip = gip;
   mp->m_quotainfo->qi_pquotaip = pip;
   return 0;
 error_rele:
-  if (uip) IRELE(uip);
-  if (gip) IRELE(gip);
-  if (pip) IRELE(pip);
+  if (uip) xfs_irele(uip);
+  if (gip) xfs_irele(gip);
+  if (pip) xfs_irele(pip);
   return error;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,27 +1,27 @@
 void xfs_qm_unmount_quotas(xfs_mount_t *mp) {
   /*
    * Release the dquots that root inode, et al might be holding,
    * before we flush quotas and blow away the quotainfo structure.
    */
   ASSERT(mp->m_rootip);
   xfs_qm_dqdetach(mp->m_rootip);
   if (mp->m_rbmip) xfs_qm_dqdetach(mp->m_rbmip);
   if (mp->m_rsumip) xfs_qm_dqdetach(mp->m_rsumip);
   /*
    * Release the quota inodes.
    */
   if (mp->m_quotainfo) {
     if (mp->m_quotainfo->qi_uquotaip) {
-      IRELE(mp->m_quotainfo->qi_uquotaip);
+      xfs_irele(mp->m_quotainfo->qi_uquotaip);
       mp->m_quotainfo->qi_uquotaip = NULL;
     }
     if (mp->m_quotainfo->qi_gquotaip) {
-      IRELE(mp->m_quotainfo->qi_gquotaip);
+      xfs_irele(mp->m_quotainfo->qi_gquotaip);
       mp->m_quotainfo->qi_gquotaip = NULL;
     }
     if (mp->m_quotainfo->qi_pquotaip) {
-      IRELE(mp->m_quotainfo->qi_pquotaip);
+      xfs_irele(mp->m_quotainfo->qi_pquotaip);
       mp->m_quotainfo->qi_pquotaip = NULL;
     }
   }
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,20 +1,20 @@
 static void xfs_qm_fill_state(struct qc_type_state *tstate, struct xfs_mount *mp, struct xfs_inode *ip, xfs_ino_t ino) {
   struct xfs_quotainfo *q = mp->m_quotainfo;
   bool tempqip = false;
   tstate->ino = ino;
   if (!ip && ino == NULLFSINO) return;
   if (!ip) {
     if (xfs_iget(mp, NULL, ino, 0, 0, &ip)) return;
     tempqip = true;
   }
   tstate->flags |= QCI_SYSFILE;
   tstate->blocks = ip->i_d.di_nblocks;
   tstate->nextents = ip->i_d.di_nextents;
   tstate->spc_timelimit = q->qi_btimelimit;
   tstate->ino_timelimit = q->qi_itimelimit;
   tstate->rt_spc_timelimit = q->qi_rtbtimelimit;
   tstate->spc_warnlimit = q->qi_bwarnlimit;
   tstate->ino_warnlimit = q->qi_iwarnlimit;
   tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit;
-  if (tempqip) IRELE(ip);
+  if (tempqip) xfs_irele(ip);
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,19 +1,19 @@
 int                                 /* error */
 xfs_rtmount_inodes(xfs_mount_t *mp) /* file system mount structure */
 {
   int error; /* error return value */
   xfs_sb_t *sbp;
   sbp = &mp->m_sb;
   if (sbp->sb_rbmino == NULLFSINO) return 0;
   error = xfs_iget(mp, NULL, sbp->sb_rbmino, 0, 0, &mp->m_rbmip);
   if (error) return error;
   ASSERT(mp->m_rbmip != NULL);
   ASSERT(sbp->sb_rsumino != NULLFSINO);
   error = xfs_iget(mp, NULL, sbp->sb_rsumino, 0, 0, &mp->m_rsumip);
   if (error) {
-    IRELE(mp->m_rbmip);
+    xfs_irele(mp->m_rbmip);
     return error;
   }
   ASSERT(mp->m_rsumip != NULL);
   return 0;
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);
--- initial
+++ final
@@ -1,4 +1,4 @@
 void xfs_rtunmount_inodes(struct xfs_mount *mp) {
-  if (mp->m_rbmip) IRELE(mp->m_rbmip);
-  if (mp->m_rsumip) IRELE(mp->m_rsumip);
+  if (mp->m_rbmip) xfs_irele(mp->m_rbmip);
+  if (mp->m_rsumip) xfs_irele(mp->m_rsumip);
 }<sep>@@
expression dp;
@@
-               IRELE(dp);
+               xfs_irele(dp);