fs/xfs/xfs_vnodeops.c

   1 /*
   2  * Copyright (c) 2000-2006 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
  19 #include "xfs.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_types.h"
  22 #include "xfs_bit.h"
  23 #include "xfs_log.h"
  24 #include "xfs_inum.h"
  25 #include "xfs_trans.h"
  26 #include "xfs_sb.h"
  27 #include "xfs_ag.h"
  28 #include "xfs_dir2.h"
  29 #include "xfs_dmapi.h"
  30 #include "xfs_mount.h"
  31 #include "xfs_da_btree.h"
  32 #include "xfs_bmap_btree.h"
  33 #include "xfs_alloc_btree.h"
  34 #include "xfs_ialloc_btree.h"
  35 #include "xfs_dir2_sf.h"
  36 #include "xfs_attr_sf.h"
  37 #include "xfs_dinode.h"
  38 #include "xfs_inode.h"
  39 #include "xfs_inode_item.h"
  40 #include "xfs_itable.h"
  41 #include "xfs_btree.h"
  42 #include "xfs_ialloc.h"
  43 #include "xfs_alloc.h"
  44 #include "xfs_bmap.h"
  45 #include "xfs_attr.h"
  46 #include "xfs_rw.h"
  47 #include "xfs_error.h"
  48 #include "xfs_quota.h"
  49 #include "xfs_utils.h"
  50 #include "xfs_rtalloc.h"
  51 #include "xfs_refcache.h"
  52 #include "xfs_trans_space.h"
  53 #include "xfs_log_priv.h"
  54
  55 STATIC int
  56 xfs_open(
  57         bhv_desc_t      *bdp,
  58         cred_t          *credp)
  59 {
  60         int             mode;
  61         bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
  62         xfs_inode_t     *ip = XFS_BHVTOI(bdp);
  63
  64         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
  65                 return XFS_ERROR(EIO);
  66
  67         /*
  68          * If it's a directory with any blocks, read-ahead block 0
  69          * as we're almost certain to have the next operation be a read there.
  70          */
  71         if (VN_ISDIR(vp) && ip->i_d.di_nextents > 0) {
  72                 mode = xfs_ilock_map_shared(ip);
  73                 if (ip->i_d.di_nextents > 0)
  74                         (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK);
  75                 xfs_iunlock(ip, mode);
  76         }
  77         return 0;
  78 }
  79
  80 STATIC int
  81 xfs_close(
  82         bhv_desc_t      *bdp,
  83         int             flags,
  84         lastclose_t     lastclose,
  85         cred_t          *credp)
  86 {
  87         bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
  88         xfs_inode_t     *ip = XFS_BHVTOI(bdp);
  89
  90         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
  91                 return XFS_ERROR(EIO);
  92
  93         if (lastclose != L_TRUE || !VN_ISREG(vp))
  94                 return 0;
  95
  96         /*
  97          * If we previously truncated this file and removed old data in
  98          * the process, we want to initiate "early" writeout on the last
  99          * close.  This is an attempt to combat the notorious NULL files
 100          * problem which is particularly noticable from a truncate down,
 101          * buffered (re-)write (delalloc), followed by a crash.  What we
 102          * are effectively doing here is significantly reducing the time
 103          * window where we'd otherwise be exposed to that problem.
 104          */
 105         if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
 106                 return bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
 107         return 0;
 108 }
 109
 110 /*
 111  * xfs_getattr
 112  */
 113 STATIC int
 114 xfs_getattr(
 115         bhv_desc_t      *bdp,
 116         bhv_vattr_t     *vap,
 117         int             flags,
 118         cred_t          *credp)
 119 {
 120         xfs_inode_t     *ip;
 121         xfs_mount_t     *mp;
 122         bhv_vnode_t     *vp;
 123
 124         vp  = BHV_TO_VNODE(bdp);
 125         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
 126
 127         ip = XFS_BHVTOI(bdp);
 128         mp = ip->i_mount;
 129
 130         if (XFS_FORCED_SHUTDOWN(mp))
 131                 return XFS_ERROR(EIO);
 132
 133         if (!(flags & ATTR_LAZY))
 134                 xfs_ilock(ip, XFS_ILOCK_SHARED);
 135
 136         vap->va_size = XFS_ISIZE(ip);
 137         if (vap->va_mask == XFS_AT_SIZE)
 138                 goto all_done;
 139
 140         vap->va_nblocks =
 141                 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
 142         vap->va_nodeid = ip->i_ino;
 143 #if XFS_BIG_INUMS
 144         vap->va_nodeid += mp->m_inoadd;
 145 #endif
 146         vap->va_nlink = ip->i_d.di_nlink;
 147
 148         /*
 149          * Quick exit for non-stat callers
 150          */
 151         if ((vap->va_mask &
 152             ~(XFS_AT_SIZE|XFS_AT_FSID|XFS_AT_NODEID|
 153               XFS_AT_NLINK|XFS_AT_BLKSIZE)) == 0)
 154                 goto all_done;
 155
 156         /*
 157          * Copy from in-core inode.
 158          */
 159         vap->va_mode = ip->i_d.di_mode;
 160         vap->va_uid = ip->i_d.di_uid;
 161         vap->va_gid = ip->i_d.di_gid;
 162         vap->va_projid = ip->i_d.di_projid;
 163
 164         /*
 165          * Check vnode type block/char vs. everything else.
 166          */
 167         switch (ip->i_d.di_mode & S_IFMT) {
 168         case S_IFBLK:
 169         case S_IFCHR:
 170                 vap->va_rdev = ip->i_df.if_u2.if_rdev;
 171                 vap->va_blocksize = BLKDEV_IOSIZE;
 172                 break;
 173         default:
 174                 vap->va_rdev = 0;
 175
 176                 if (!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) {
 177                         vap->va_blocksize = xfs_preferred_iosize(mp);
 178                 } else {
 179
 180                         /*
 181                          * If the file blocks are being allocated from a
 182                          * realtime partition, then return the inode's
 183                          * realtime extent size or the realtime volume's
 184                          * extent size.
 185                          */
 186                         vap->va_blocksize = ip->i_d.di_extsize ?
 187                                 (ip->i_d.di_extsize << mp->m_sb.sb_blocklog) :
 188                                 (mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog);
 189                 }
 190                 break;
 191         }
 192
 193         vn_atime_to_timespec(vp, &vap->va_atime);
 194         vap->va_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
 195         vap->va_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
 196         vap->va_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
 197         vap->va_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
 198
 199         /*
 200          * Exit for stat callers.  See if any of the rest of the fields
 201          * to be filled in are needed.
 202          */
 203         if ((vap->va_mask &
 204              (XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|
 205               XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0)
 206                 goto all_done;
 207
 208         /*
 209          * Convert di_flags to xflags.
 210          */
 211         vap->va_xflags = xfs_ip2xflags(ip);
 212
 213         /*
 214          * Exit for inode revalidate.  See if any of the rest of
 215          * the fields to be filled in are needed.
 216          */
 217         if ((vap->va_mask &
 218              (XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|
 219               XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0)
 220                 goto all_done;
 221
 222         vap->va_extsize = ip->i_d.di_extsize << mp->m_sb.sb_blocklog;
 223         vap->va_nextents =
 224                 (ip->i_df.if_flags & XFS_IFEXTENTS) ?
 225                         ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) :
 226                         ip->i_d.di_nextents;
 227         if (ip->i_afp)
 228                 vap->va_anextents =
 229                         (ip->i_afp->if_flags & XFS_IFEXTENTS) ?
 230                                 ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) :
 231                                  ip->i_d.di_anextents;
 232         else
 233                 vap->va_anextents = 0;
 234         vap->va_gen = ip->i_d.di_gen;
 235
 236  all_done:
 237         if (!(flags & ATTR_LAZY))
 238                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
 239         return 0;
 240 }
 241
 242
 243 /*
 244  * xfs_setattr
 245  */
 246 int
 247 xfs_setattr(
 248         bhv_desc_t              *bdp,
 249         bhv_vattr_t             *vap,
 250         int                     flags,
 251         cred_t                  *credp)
 252 {
 253         xfs_inode_t             *ip;
 254         xfs_trans_t             *tp;
 255         xfs_mount_t             *mp;
 256         int                     mask;
 257         int                     code;
 258         uint                    lock_flags;
 259         uint                    commit_flags=0;
 260         uid_t                   uid=0, iuid=0;
 261         gid_t                   gid=0, igid=0;
 262         int                     timeflags = 0;
 263         bhv_vnode_t             *vp;
 264         xfs_prid_t              projid=0, iprojid=0;
 265         int                     mandlock_before, mandlock_after;
 266         struct xfs_dquot        *udqp, *gdqp, *olddquot1, *olddquot2;
 267         int                     file_owner;
 268         int                     need_iolock = 1;
 269
 270         vp = BHV_TO_VNODE(bdp);
 271         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
 272
 273         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
 274                 return XFS_ERROR(EROFS);
 275
 276         /*
 277          * Cannot set certain attributes.
 278          */
 279         mask = vap->va_mask;
 280         if (mask & XFS_AT_NOSET) {
 281                 return XFS_ERROR(EINVAL);
 282         }
 283
 284         ip = XFS_BHVTOI(bdp);
 285         mp = ip->i_mount;
 286
 287         if (XFS_FORCED_SHUTDOWN(mp))
 288                 return XFS_ERROR(EIO);
 289
 290         /*
 291          * Timestamps do not need to be logged and hence do not
 292          * need to be done within a transaction.
 293          */
 294         if (mask & XFS_AT_UPDTIMES) {
 295                 ASSERT((mask & ~XFS_AT_UPDTIMES) == 0);
 296                 timeflags = ((mask & XFS_AT_UPDATIME) ? XFS_ICHGTIME_ACC : 0) |
 297                             ((mask & XFS_AT_UPDCTIME) ? XFS_ICHGTIME_CHG : 0) |
 298                             ((mask & XFS_AT_UPDMTIME) ? XFS_ICHGTIME_MOD : 0);
 299                 xfs_ichgtime(ip, timeflags);
 300                 return 0;
 301         }
 302
 303         olddquot1 = olddquot2 = NULL;
 304         udqp = gdqp = NULL;
 305
 306         /*
 307          * If disk quotas is on, we make sure that the dquots do exist on disk,
 308          * before we start any other transactions. Trying to do this later
 309          * is messy. We don't care to take a readlock to look at the ids
 310          * in inode here, because we can't hold it across the trans_reserve.
 311          * If the IDs do change before we take the ilock, we're covered
 312          * because the i_*dquot fields will get updated anyway.
 313          */
 314         if (XFS_IS_QUOTA_ON(mp) &&
 315             (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID))) {
 316                 uint    qflags = 0;
 317
 318                 if ((mask & XFS_AT_UID) && XFS_IS_UQUOTA_ON(mp)) {
 319                         uid = vap->va_uid;
 320                         qflags |= XFS_QMOPT_UQUOTA;
 321                 } else {
 322                         uid = ip->i_d.di_uid;
 323                 }
 324                 if ((mask & XFS_AT_GID) && XFS_IS_GQUOTA_ON(mp)) {
 325                         gid = vap->va_gid;
 326                         qflags |= XFS_QMOPT_GQUOTA;
 327                 }  else {
 328                         gid = ip->i_d.di_gid;
 329                 }
 330                 if ((mask & XFS_AT_PROJID) && XFS_IS_PQUOTA_ON(mp)) {
 331                         projid = vap->va_projid;
 332                         qflags |= XFS_QMOPT_PQUOTA;
 333                 }  else {
 334                         projid = ip->i_d.di_projid;
 335                 }
 336                 /*
 337                  * We take a reference when we initialize udqp and gdqp,
 338                  * so it is important that we never blindly double trip on
 339                  * the same variable. See xfs_create() for an example.
 340                  */
 341                 ASSERT(udqp == NULL);
 342                 ASSERT(gdqp == NULL);
 343                 code = XFS_QM_DQVOPALLOC(mp, ip, uid, gid, projid, qflags,
 344                                          &udqp, &gdqp);
 345                 if (code)
 346                         return code;
 347         }
 348
 349         /*
 350          * For the other attributes, we acquire the inode lock and
 351          * first do an error checking pass.
 352          */
 353         tp = NULL;
 354         lock_flags = XFS_ILOCK_EXCL;
 355         if (flags & ATTR_NOLOCK)
 356                 need_iolock = 0;
 357         if (!(mask & XFS_AT_SIZE)) {
 358                 if ((mask != (XFS_AT_CTIME|XFS_AT_ATIME|XFS_AT_MTIME)) ||
 359                     (mp->m_flags & XFS_MOUNT_WSYNC)) {
 360                         tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
 361                         commit_flags = 0;
 362                         if ((code = xfs_trans_reserve(tp, 0,
 363                                                      XFS_ICHANGE_LOG_RES(mp), 0,
 364                                                      0, 0))) {
 365                                 lock_flags = 0;
 366                                 goto error_return;
 367                         }
 368                 }
 369         } else {
 370                 if (DM_EVENT_ENABLED (vp->v_vfsp, ip, DM_EVENT_TRUNCATE) &&
 371                     !(flags & ATTR_DMI)) {
 372                         int dmflags = AT_DELAY_FLAG(flags) | DM_SEM_FLAG_WR;
 373                         code = XFS_SEND_DATA(mp, DM_EVENT_TRUNCATE, vp,
 374                                 vap->va_size, 0, dmflags, NULL);
 375                         if (code) {
 376                                 lock_flags = 0;
 377                                 goto error_return;
 378                         }
 379                 }
 380                 if (need_iolock)
 381                         lock_flags |= XFS_IOLOCK_EXCL;
 382         }
 383
 384         xfs_ilock(ip, lock_flags);
 385
 386         /* boolean: are we the file owner? */
 387         file_owner = (current_fsuid(credp) == ip->i_d.di_uid);
 388
 389         /*
 390          * Change various properties of a file.
 391          * Only the owner or users with CAP_FOWNER
 392          * capability may do these things.
 393          */
 394         if (mask &
 395             (XFS_AT_MODE|XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_UID|
 396              XFS_AT_GID|XFS_AT_PROJID)) {
 397                 /*
 398                  * CAP_FOWNER overrides the following restrictions:
 399                  *
 400                  * The user ID of the calling process must be equal
 401                  * to the file owner ID, except in cases where the
 402                  * CAP_FSETID capability is applicable.
 403                  */
 404                 if (!file_owner && !capable(CAP_FOWNER)) {
 405                         code = XFS_ERROR(EPERM);
 406                         goto error_return;
 407                 }
 408
 409                 /*
 410                  * CAP_FSETID overrides the following restrictions:
 411                  *
 412                  * The effective user ID of the calling process shall match
 413                  * the file owner when setting the set-user-ID and
 414                  * set-group-ID bits on that file.
 415                  *
 416                  * The effective group ID or one of the supplementary group
 417                  * IDs of the calling process shall match the group owner of
 418                  * the file when setting the set-group-ID bit on that file
 419                  */
 420                 if (mask & XFS_AT_MODE) {
 421                         mode_t m = 0;
 422
 423                         if ((vap->va_mode & S_ISUID) && !file_owner)
 424                                 m |= S_ISUID;
 425                         if ((vap->va_mode & S_ISGID) &&
 426                             !in_group_p((gid_t)ip->i_d.di_gid))
 427                                 m |= S_ISGID;
 428 #if 0
 429                         /* Linux allows this, Irix doesn't. */
 430                         if ((vap->va_mode & S_ISVTX) && !VN_ISDIR(vp))
 431                                 m |= S_ISVTX;
 432 #endif
 433                         if (m && !capable(CAP_FSETID))
 434                                 vap->va_mode &= ~m;
 435                 }
 436         }
 437
 438         /*
 439          * Change file ownership.  Must be the owner or privileged.
 440          * If the system was configured with the "restricted_chown"
 441          * option, the owner is not permitted to give away the file,
 442          * and can change the group id only to a group of which he
 443          * or she is a member.
 444          */
 445         if (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID)) {
 446                 /*
 447                  * These IDs could have changed since we last looked at them.
 448                  * But, we're assured that if the ownership did change
 449                  * while we didn't have the inode locked, inode's dquot(s)
 450                  * would have changed also.
 451                  */
 452                 iuid = ip->i_d.di_uid;
 453                 iprojid = ip->i_d.di_projid;
 454                 igid = ip->i_d.di_gid;
 455                 gid = (mask & XFS_AT_GID) ? vap->va_gid : igid;
 456                 uid = (mask & XFS_AT_UID) ? vap->va_uid : iuid;
 457                 projid = (mask & XFS_AT_PROJID) ? (xfs_prid_t)vap->va_projid :
 458                          iprojid;
 459
 460                 /*
 461                  * CAP_CHOWN overrides the following restrictions:
 462                  *
 463                  * If _POSIX_CHOWN_RESTRICTED is defined, this capability
 464                  * shall override the restriction that a process cannot
 465                  * change the user ID of a file it owns and the restriction
 466                  * that the group ID supplied to the chown() function
 467                  * shall be equal to either the group ID or one of the
 468                  * supplementary group IDs of the calling process.
 469                  */
 470                 if (restricted_chown &&
 471                     (iuid != uid || (igid != gid &&
 472                                      !in_group_p((gid_t)gid))) &&
 473                     !capable(CAP_CHOWN)) {
 474                         code = XFS_ERROR(EPERM);
 475                         goto error_return;
 476                 }
 477                 /*
 478                  * Do a quota reservation only if uid/projid/gid is actually
 479                  * going to change.
 480                  */
 481                 if ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||
 482                     (XFS_IS_PQUOTA_ON(mp) && iprojid != projid) ||
 483                     (XFS_IS_GQUOTA_ON(mp) && igid != gid)) {
 484                         ASSERT(tp);
 485                         code = XFS_QM_DQVOPCHOWNRESV(mp, tp, ip, udqp, gdqp,
 486                                                 capable(CAP_FOWNER) ?
 487                                                 XFS_QMOPT_FORCE_RES : 0);
 488                         if (code)       /* out of quota */
 489                                 goto error_return;
 490                 }
 491         }
 492
 493         /*
 494          * Truncate file.  Must have write permission and not be a directory.
 495          */
 496         if (mask & XFS_AT_SIZE) {
 497                 /* Short circuit the truncate case for zero length files */
 498                 if ((vap->va_size == 0) &&
 499                    (ip->i_size == 0) && (ip->i_d.di_nextents == 0)) {
 500                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 501                         lock_flags &= ~XFS_ILOCK_EXCL;
 502                         if (mask & XFS_AT_CTIME)
 503                                 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 504                         code = 0;
 505                         goto error_return;
 506                 }
 507
 508                 if (VN_ISDIR(vp)) {
 509                         code = XFS_ERROR(EISDIR);
 510                         goto error_return;
 511                 } else if (!VN_ISREG(vp)) {
 512                         code = XFS_ERROR(EINVAL);
 513                         goto error_return;
 514                 }
 515                 /*
 516                  * Make sure that the dquots are attached to the inode.
 517                  */
 518                 if ((code = XFS_QM_DQATTACH(mp, ip, XFS_QMOPT_ILOCKED)))
 519                         goto error_return;
 520         }
 521
 522         /*
 523          * Change file access or modified times.
 524          */
 525         if (mask & (XFS_AT_ATIME|XFS_AT_MTIME)) {
 526                 if (!file_owner) {
 527                         if ((flags & ATTR_UTIME) &&
 528                             !capable(CAP_FOWNER)) {
 529                                 code = XFS_ERROR(EPERM);
 530                                 goto error_return;
 531                         }
 532                 }
 533         }
 534
 535         /*
 536          * Change extent size or realtime flag.
 537          */
 538         if (mask & (XFS_AT_EXTSIZE|XFS_AT_XFLAGS)) {
 539                 /*
 540                  * Can't change extent size if any extents are allocated.
 541                  */
 542                 if (ip->i_d.di_nextents && (mask & XFS_AT_EXTSIZE) &&
 543                     ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
 544                      vap->va_extsize) ) {
 545                         code = XFS_ERROR(EINVAL);       /* EFBIG? */
 546                         goto error_return;
 547                 }
 548
 549                 /*
 550                  * Can't change realtime flag if any extents are allocated.
 551                  */
 552                 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
 553                     (mask & XFS_AT_XFLAGS) &&
 554                     (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) !=
 555                     (vap->va_xflags & XFS_XFLAG_REALTIME)) {
 556                         code = XFS_ERROR(EINVAL);       /* EFBIG? */
 557                         goto error_return;
 558                 }
 559                 /*
 560                  * Extent size must be a multiple of the appropriate block
 561                  * size, if set at all.
 562                  */
 563                 if ((mask & XFS_AT_EXTSIZE) && vap->va_extsize != 0) {
 564                         xfs_extlen_t    size;
 565
 566                         if ((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ||
 567                             ((mask & XFS_AT_XFLAGS) &&
 568                             (vap->va_xflags & XFS_XFLAG_REALTIME))) {
 569                                 size = mp->m_sb.sb_rextsize <<
 570                                        mp->m_sb.sb_blocklog;
 571                         } else {
 572                                 size = mp->m_sb.sb_blocksize;
 573                         }
 574                         if (vap->va_extsize % size) {
 575                                 code = XFS_ERROR(EINVAL);
 576                                 goto error_return;
 577                         }
 578                 }
 579                 /*
 580                  * If realtime flag is set then must have realtime data.
 581                  */
 582                 if ((mask & XFS_AT_XFLAGS) &&
 583                     (vap->va_xflags & XFS_XFLAG_REALTIME)) {
 584                         if ((mp->m_sb.sb_rblocks == 0) ||
 585                             (mp->m_sb.sb_rextsize == 0) ||
 586                             (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
 587                                 code = XFS_ERROR(EINVAL);
 588                                 goto error_return;
 589                         }
 590                 }
 591
 592                 /*
 593                  * Can't modify an immutable/append-only file unless
 594                  * we have appropriate permission.
 595                  */
 596                 if ((mask & XFS_AT_XFLAGS) &&
 597                     (ip->i_d.di_flags &
 598                                 (XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
 599                      (vap->va_xflags &
 600                                 (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
 601                     !capable(CAP_LINUX_IMMUTABLE)) {
 602                         code = XFS_ERROR(EPERM);
 603                         goto error_return;
 604                 }
 605         }
 606
 607         /*
 608          * Now we can make the changes.  Before we join the inode
 609          * to the transaction, if XFS_AT_SIZE is set then take care of
 610          * the part of the truncation that must be done without the
 611          * inode lock.  This needs to be done before joining the inode
 612          * to the transaction, because the inode cannot be unlocked
 613          * once it is a part of the transaction.
 614          */
 615         if (mask & XFS_AT_SIZE) {
 616                 code = 0;
 617                 if ((vap->va_size > ip->i_size) &&
 618                     (flags & ATTR_NOSIZETOK) == 0) {
 619                         code = xfs_igrow_start(ip, vap->va_size, credp);
 620                 }
 621                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 622                 vn_iowait(vp); /* wait for the completion of any pending DIOs */
 623                 if (!code)
 624                         code = xfs_itruncate_data(ip, vap->va_size);
 625                 if (code) {
 626                         ASSERT(tp == NULL);
 627                         lock_flags &= ~XFS_ILOCK_EXCL;
 628                         ASSERT(lock_flags == XFS_IOLOCK_EXCL);
 629                         goto error_return;
 630                 }
 631                 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
 632                 if ((code = xfs_trans_reserve(tp, 0,
 633                                              XFS_ITRUNCATE_LOG_RES(mp), 0,
 634                                              XFS_TRANS_PERM_LOG_RES,
 635                                              XFS_ITRUNCATE_LOG_COUNT))) {
 636                         xfs_trans_cancel(tp, 0);
 637                         if (need_iolock)
 638                                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 639                         return code;
 640                 }
 641                 commit_flags = XFS_TRANS_RELEASE_LOG_RES;
 642                 xfs_ilock(ip, XFS_ILOCK_EXCL);
 643         }
 644
 645         if (tp) {
 646                 xfs_trans_ijoin(tp, ip, lock_flags);
 647                 xfs_trans_ihold(tp, ip);
 648         }
 649
 650         /* determine whether mandatory locking mode changes */
 651         mandlock_before = MANDLOCK(vp, ip->i_d.di_mode);
 652
 653         /*
 654          * Truncate file.  Must have write permission and not be a directory.
 655          */
 656         if (mask & XFS_AT_SIZE) {
 657                 if (vap->va_size > ip->i_size) {
 658                         xfs_igrow_finish(tp, ip, vap->va_size,
 659                             !(flags & ATTR_DMI));
 660                 } else if ((vap->va_size <= ip->i_size) ||
 661                            ((vap->va_size == 0) && ip->i_d.di_nextents)) {
 662                         /*
 663                          * signal a sync transaction unless
 664                          * we're truncating an already unlinked
 665                          * file on a wsync filesystem
 666                          */
 667                         code = xfs_itruncate_finish(&tp, ip,
 668                                             (xfs_fsize_t)vap->va_size,
 669                                             XFS_DATA_FORK,
 670                                             ((ip->i_d.di_nlink != 0 ||
 671                                               !(mp->m_flags & XFS_MOUNT_WSYNC))
 672                                              ? 1 : 0));
 673                         if (code)
 674                                 goto abort_return;
 675                         /*
 676                          * Truncated "down", so we're removing references
 677                          * to old data here - if we now delay flushing for
 678                          * a long time, we expose ourselves unduly to the
 679                          * notorious NULL files problem.  So, we mark this
 680                          * vnode and flush it when the file is closed, and
 681                          * do not wait the usual (long) time for writeout.
 682                          */
 683                         VTRUNCATE(vp);
 684                 }
 685                 /*
 686                  * Have to do this even if the file's size doesn't change.
 687                  */
 688                 timeflags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
 689         }
 690
 691         /*
 692          * Change file access modes.
 693          */
 694         if (mask & XFS_AT_MODE) {
 695                 ip->i_d.di_mode &= S_IFMT;
 696                 ip->i_d.di_mode |= vap->va_mode & ~S_IFMT;
 697
 698                 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
 699                 timeflags |= XFS_ICHGTIME_CHG;
 700         }
 701
 702         /*
 703          * Change file ownership.  Must be the owner or privileged.
 704          * If the system was configured with the "restricted_chown"
 705          * option, the owner is not permitted to give away the file,
 706          * and can change the group id only to a group of which he
 707          * or she is a member.
 708          */
 709         if (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID)) {
 710                 /*
 711                  * CAP_FSETID overrides the following restrictions:
 712                  *
 713                  * The set-user-ID and set-group-ID bits of a file will be
 714                  * cleared upon successful return from chown()
 715                  */
 716                 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
 717                     !capable(CAP_FSETID)) {
 718                         ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
 719                 }
 720
 721                 /*
 722                  * Change the ownerships and register quota modifications
 723                  * in the transaction.
 724                  */
 725                 if (iuid != uid) {
 726                         if (XFS_IS_UQUOTA_ON(mp)) {
 727                                 ASSERT(mask & XFS_AT_UID);
 728                                 ASSERT(udqp);
 729                                 olddquot1 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
 730                                                         &ip->i_udquot, udqp);
 731                         }
 732                         ip->i_d.di_uid = uid;
 733                 }
 734                 if (igid != gid) {
 735                         if (XFS_IS_GQUOTA_ON(mp)) {
 736                                 ASSERT(!XFS_IS_PQUOTA_ON(mp));
 737                                 ASSERT(mask & XFS_AT_GID);
 738                                 ASSERT(gdqp);
 739                                 olddquot2 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
 740                                                         &ip->i_gdquot, gdqp);
 741                         }
 742                         ip->i_d.di_gid = gid;
 743                 }
 744                 if (iprojid != projid) {
 745                         if (XFS_IS_PQUOTA_ON(mp)) {
 746                                 ASSERT(!XFS_IS_GQUOTA_ON(mp));
 747                                 ASSERT(mask & XFS_AT_PROJID);
 748                                 ASSERT(gdqp);
 749                                 olddquot2 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
 750                                                         &ip->i_gdquot, gdqp);
 751                         }
 752                         ip->i_d.di_projid = projid;
 753                         /*
 754                          * We may have to rev the inode as well as
 755                          * the superblock version number since projids didn't
 756                          * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
 757                          */
 758                         if (ip->i_d.di_version == XFS_DINODE_VERSION_1)
 759                                 xfs_bump_ino_vers2(tp, ip);
 760                 }
 761
 762                 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
 763                 timeflags |= XFS_ICHGTIME_CHG;
 764         }
 765
 766
 767         /*
 768          * Change file access or modified times.
 769          */
 770         if (mask & (XFS_AT_ATIME|XFS_AT_MTIME)) {
 771                 if (mask & XFS_AT_ATIME) {
 772                         ip->i_d.di_atime.t_sec = vap->va_atime.tv_sec;
 773                         ip->i_d.di_atime.t_nsec = vap->va_atime.tv_nsec;
 774                         ip->i_update_core = 1;
 775                         timeflags &= ~XFS_ICHGTIME_ACC;
 776                 }
 777                 if (mask & XFS_AT_MTIME) {
 778                         ip->i_d.di_mtime.t_sec = vap->va_mtime.tv_sec;
 779                         ip->i_d.di_mtime.t_nsec = vap->va_mtime.tv_nsec;
 780                         timeflags &= ~XFS_ICHGTIME_MOD;
 781                         timeflags |= XFS_ICHGTIME_CHG;
 782                 }
 783                 if (tp && (flags & ATTR_UTIME))
 784                         xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
 785         }
 786
 787         /*
 788          * Change XFS-added attributes.
 789          */
 790         if (mask & (XFS_AT_EXTSIZE|XFS_AT_XFLAGS)) {
 791                 if (mask & XFS_AT_EXTSIZE) {
 792                         /*
 793                          * Converting bytes to fs blocks.
 794                          */
 795                         ip->i_d.di_extsize = vap->va_extsize >>
 796                                 mp->m_sb.sb_blocklog;
 797                 }
 798                 if (mask & XFS_AT_XFLAGS) {
 799                         uint    di_flags;
 800
 801                         /* can't set PREALLOC this way, just preserve it */
 802                         di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
 803                         if (vap->va_xflags & XFS_XFLAG_IMMUTABLE)
 804                                 di_flags |= XFS_DIFLAG_IMMUTABLE;
 805                         if (vap->va_xflags & XFS_XFLAG_APPEND)
 806                                 di_flags |= XFS_DIFLAG_APPEND;
 807                         if (vap->va_xflags & XFS_XFLAG_SYNC)
 808                                 di_flags |= XFS_DIFLAG_SYNC;
 809                         if (vap->va_xflags & XFS_XFLAG_NOATIME)
 810                                 di_flags |= XFS_DIFLAG_NOATIME;
 811                         if (vap->va_xflags & XFS_XFLAG_NODUMP)
 812                                 di_flags |= XFS_DIFLAG_NODUMP;
 813                         if (vap->va_xflags & XFS_XFLAG_PROJINHERIT)
 814                                 di_flags |= XFS_DIFLAG_PROJINHERIT;
 815                         if (vap->va_xflags & XFS_XFLAG_NODEFRAG)
 816                                 di_flags |= XFS_DIFLAG_NODEFRAG;
 817                         if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
 818                                 if (vap->va_xflags & XFS_XFLAG_RTINHERIT)
 819                                         di_flags |= XFS_DIFLAG_RTINHERIT;
 820                                 if (vap->va_xflags & XFS_XFLAG_NOSYMLINKS)
 821                                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
 822                                 if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT)
 823                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 824                         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
 825                                 if (vap->va_xflags & XFS_XFLAG_REALTIME) {
 826                                         di_flags |= XFS_DIFLAG_REALTIME;
 827                                         ip->i_iocore.io_flags |= XFS_IOCORE_RT;
 828                                 } else {
 829                                         ip->i_iocore.io_flags &= ~XFS_IOCORE_RT;
 830                                 }
 831                                 if (vap->va_xflags & XFS_XFLAG_EXTSIZE)
 832                                         di_flags |= XFS_DIFLAG_EXTSIZE;
 833                         }
 834                         ip->i_d.di_flags = di_flags;
 835                 }
 836                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 837                 timeflags |= XFS_ICHGTIME_CHG;
 838         }
 839
 840         /*
 841          * Change file inode change time only if XFS_AT_CTIME set
 842          * AND we have been called by a DMI function.
 843          */
 844
 845         if ( (flags & ATTR_DMI) && (mask & XFS_AT_CTIME) ) {
 846                 ip->i_d.di_ctime.t_sec = vap->va_ctime.tv_sec;
 847                 ip->i_d.di_ctime.t_nsec = vap->va_ctime.tv_nsec;
 848                 ip->i_update_core = 1;
 849                 timeflags &= ~XFS_ICHGTIME_CHG;
 850         }
 851
 852         /*
 853          * Send out timestamp changes that need to be set to the
 854          * current time.  Not done when called by a DMI function.
 855          */
 856         if (timeflags && !(flags & ATTR_DMI))
 857                 xfs_ichgtime(ip, timeflags);
 858
 859         XFS_STATS_INC(xs_ig_attrchg);
 860
 861         /*
 862          * If this is a synchronous mount, make sure that the
 863          * transaction goes to disk before returning to the user.
 864          * This is slightly sub-optimal in that truncates require
 865          * two sync transactions instead of one for wsync filesystems.
 866          * One for the truncate and one for the timestamps since we
 867          * don't want to change the timestamps unless we're sure the
 868          * truncate worked.  Truncates are less than 1% of the laddis
 869          * mix so this probably isn't worth the trouble to optimize.
 870          */
 871         code = 0;
 872         if (tp) {
 873                 if (mp->m_flags & XFS_MOUNT_WSYNC)
 874                         xfs_trans_set_sync(tp);
 875
 876                 code = xfs_trans_commit(tp, commit_flags);
 877         }
 878
 879         /*
 880          * If the (regular) file's mandatory locking mode changed, then
 881          * notify the vnode.  We do this under the inode lock to prevent
 882          * racing calls to vop_vnode_change.
 883          */
 884         mandlock_after = MANDLOCK(vp, ip->i_d.di_mode);
 885         if (mandlock_before != mandlock_after) {
 886                 bhv_vop_vnode_change(vp, VCHANGE_FLAGS_ENF_LOCKING,
 887                                  mandlock_after);
 888         }
 889
 890         xfs_iunlock(ip, lock_flags);
 891
 892         /*
 893          * Release any dquot(s) the inode had kept before chown.
 894          */
 895         XFS_QM_DQRELE(mp, olddquot1);
 896         XFS_QM_DQRELE(mp, olddquot2);
 897         XFS_QM_DQRELE(mp, udqp);
 898         XFS_QM_DQRELE(mp, gdqp);
 899
 900         if (code) {
 901                 return code;
 902         }
 903
 904         if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_ATTRIBUTE) &&
 905             !(flags & ATTR_DMI)) {
 906                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, vp, DM_RIGHT_NULL,
 907                                         NULL, DM_RIGHT_NULL, NULL, NULL,
 908                                         0, 0, AT_DELAY_FLAG(flags));
 909         }
 910         return 0;
 911
 912  abort_return:
 913         commit_flags |= XFS_TRANS_ABORT;
 914         /* FALLTHROUGH */
 915  error_return:
 916         XFS_QM_DQRELE(mp, udqp);
 917         XFS_QM_DQRELE(mp, gdqp);
 918         if (tp) {
 919                 xfs_trans_cancel(tp, commit_flags);
 920         }
 921         if (lock_flags != 0) {
 922                 xfs_iunlock(ip, lock_flags);
 923         }
 924         return code;
 925 }
 926
 927
 928 /*
 929  * xfs_access
 930  * Null conversion from vnode mode bits to inode mode bits, as in efs.
 931  */
 932 STATIC int
 933 xfs_access(
 934         bhv_desc_t      *bdp,
 935         int             mode,
 936         cred_t          *credp)
 937 {
 938         xfs_inode_t     *ip;
 939         int             error;
 940
 941         vn_trace_entry(BHV_TO_VNODE(bdp), __FUNCTION__,
 942                                                (inst_t *)__return_address);
 943
 944         ip = XFS_BHVTOI(bdp);
 945         xfs_ilock(ip, XFS_ILOCK_SHARED);
 946         error = xfs_iaccess(ip, mode, credp);
 947         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 948         return error;
 949 }
 950
 951
 952 /*
 953  * The maximum pathlen is 1024 bytes. Since the minimum file system
 954  * blocksize is 512 bytes, we can get a max of 2 extents back from
 955  * bmapi.
 956  */
 957 #define SYMLINK_MAPS 2
 958
 959 /*
 960  * xfs_readlink
 961  *
 962  */
 963 STATIC int
 964 xfs_readlink(
 965         bhv_desc_t      *bdp,
 966         uio_t           *uiop,
 967         int             ioflags,
 968         cred_t          *credp)
 969 {
 970         xfs_inode_t     *ip;
 971         int             count;
 972         xfs_off_t       offset;
 973         int             pathlen;
 974         bhv_vnode_t     *vp;
 975         int             error = 0;
 976         xfs_mount_t     *mp;
 977         int             nmaps;
 978         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
 979         xfs_daddr_t     d;
 980         int             byte_cnt;
 981         int             n;
 982         xfs_buf_t       *bp;
 983
 984         vp = BHV_TO_VNODE(bdp);
 985         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
 986
 987         ip = XFS_BHVTOI(bdp);
 988         mp = ip->i_mount;
 989
 990         if (XFS_FORCED_SHUTDOWN(mp))
 991                 return XFS_ERROR(EIO);
 992
 993         xfs_ilock(ip, XFS_ILOCK_SHARED);
 994
 995         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
 996
 997         offset = uiop->uio_offset;
 998         count = uiop->uio_resid;
 999
1000         if (offset < 0) {
1001                 error = XFS_ERROR(EINVAL);
1002                 goto error_return;
1003         }
1004         if (count <= 0) {
1005                 error = 0;
1006                 goto error_return;
1007         }
1008
1009         /*
1010          * See if the symlink is stored inline.
1011          */
1012         pathlen = (int)ip->i_d.di_size;
1013
1014         if (ip->i_df.if_flags & XFS_IFINLINE) {
1015                 error = xfs_uio_read(ip->i_df.if_u1.if_data, pathlen, uiop);
1016         }
1017         else {
1018                 /*
1019                  * Symlink not inline.  Call bmap to get it in.
1020                  */
1021                 nmaps = SYMLINK_MAPS;
1022
1023                 error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen),
1024                                   0, NULL, 0, mval, &nmaps, NULL, NULL);
1025
1026                 if (error) {
1027                         goto error_return;
1028                 }
1029
1030                 for (n = 0; n < nmaps; n++) {
1031                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
1032                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
1033                         bp = xfs_buf_read(mp->m_ddev_targp, d,
1034                                       BTOBB(byte_cnt), 0);
1035                         error = XFS_BUF_GETERROR(bp);
1036                         if (error) {
1037                                 xfs_ioerror_alert("xfs_readlink",
1038                                           ip->i_mount, bp, XFS_BUF_ADDR(bp));
1039                                 xfs_buf_relse(bp);
1040                                 goto error_return;
1041                         }
1042                         if (pathlen < byte_cnt)
1043                                 byte_cnt = pathlen;
1044                         pathlen -= byte_cnt;
1045
1046                         error = xfs_uio_read(XFS_BUF_PTR(bp), byte_cnt, uiop);
1047                         xfs_buf_relse (bp);
1048                 }
1049
1050         }
1051
1052 error_return:
1053         xfs_iunlock(ip, XFS_ILOCK_SHARED);
1054         return error;
1055 }
1056
1057
1058 /*
1059  * xfs_fsync
1060  *
1061  * This is called to sync the inode and its data out to disk.
1062  * We need to hold the I/O lock while flushing the data, and
1063  * the inode lock while flushing the inode.  The inode lock CANNOT
1064  * be held while flushing the data, so acquire after we're done
1065  * with that.
1066  */
1067 STATIC int
1068 xfs_fsync(
1069         bhv_desc_t      *bdp,
1070         int             flag,
1071         cred_t          *credp,
1072         xfs_off_t       start,
1073         xfs_off_t       stop)
1074 {
1075         xfs_inode_t     *ip;
1076         xfs_trans_t     *tp;
1077         int             error;
1078         int             log_flushed = 0, changed = 1;
1079
1080         vn_trace_entry(BHV_TO_VNODE(bdp),
1081                         __FUNCTION__, (inst_t *)__return_address);
1082
1083         ip = XFS_BHVTOI(bdp);
1084
1085         ASSERT(start >= 0 && stop >= -1);
1086
1087         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
1088                 return XFS_ERROR(EIO);
1089
1090         /*
1091          * We always need to make sure that the required inode state
1092          * is safe on disk.  The vnode might be clean but because
1093          * of committed transactions that haven't hit the disk yet.
1094          * Likewise, there could be unflushed non-transactional
1095          * changes to the inode core that have to go to disk.
1096          *
1097          * The following code depends on one assumption:  that
1098          * any transaction that changes an inode logs the core
1099          * because it has to change some field in the inode core
1100          * (typically nextents or nblocks).  That assumption
1101          * implies that any transactions against an inode will
1102          * catch any non-transactional updates.  If inode-altering
1103          * transactions exist that violate this assumption, the
1104          * code breaks.  Right now, it figures that if the involved
1105          * update_* field is clear and the inode is unpinned, the
1106          * inode is clean.  Either it's been flushed or it's been
1107          * committed and the commit has hit the disk unpinning the inode.
1108          * (Note that xfs_inode_item_format() called at commit clears
1109          * the update_* fields.)
1110          */
1111         xfs_ilock(ip, XFS_ILOCK_SHARED);
1112
1113         /* If we are flushing data then we care about update_size
1114          * being set, otherwise we care about update_core
1115          */
1116         if ((flag & FSYNC_DATA) ?
1117                         (ip->i_update_size == 0) :
1118                         (ip->i_update_core == 0)) {
1119                 /*
1120                  * Timestamps/size haven't changed since last inode
1121                  * flush or inode transaction commit.  That means
1122                  * either nothing got written or a transaction
1123                  * committed which caught the updates.  If the
1124                  * latter happened and the transaction hasn't
1125                  * hit the disk yet, the inode will be still
1126                  * be pinned.  If it is, force the log.
1127                  */
1128
1129                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
1130
1131                 if (xfs_ipincount(ip)) {
1132                         _xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
1133                                       XFS_LOG_FORCE |
1134                                       ((flag & FSYNC_WAIT)
1135                                        ? XFS_LOG_SYNC : 0),
1136                                       &log_flushed);
1137                 } else {
1138                         /*
1139                          * If the inode is not pinned and nothing
1140                          * has changed we don't need to flush the
1141                          * cache.
1142                          */
1143                         changed = 0;
1144                 }
1145                 error = 0;
1146         } else  {
1147                 /*
1148                  * Kick off a transaction to log the inode
1149                  * core to get the updates.  Make it
1150                  * sync if FSYNC_WAIT is passed in (which
1151                  * is done by everybody but specfs).  The
1152                  * sync transaction will also force the log.
1153                  */
1154                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
1155                 tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_FSYNC_TS);
1156                 if ((error = xfs_trans_reserve(tp, 0,
1157                                 XFS_FSYNC_TS_LOG_RES(ip->i_mount),
1158                                 0, 0, 0)))  {
1159                         xfs_trans_cancel(tp, 0);
1160                         return error;
1161                 }
1162                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1163
1164                 /*
1165                  * Note - it's possible that we might have pushed
1166                  * ourselves out of the way during trans_reserve
1167                  * which would flush the inode.  But there's no
1168                  * guarantee that the inode buffer has actually
1169                  * gone out yet (it's delwri).  Plus the buffer
1170                  * could be pinned anyway if it's part of an
1171                  * inode in another recent transaction.  So we
1172                  * play it safe and fire off the transaction anyway.
1173                  */
1174                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1175                 xfs_trans_ihold(tp, ip);
1176                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1177                 if (flag & FSYNC_WAIT)
1178                         xfs_trans_set_sync(tp);
1179                 error = _xfs_trans_commit(tp, 0, &log_flushed);
1180
1181                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1182         }
1183
1184         if ((ip->i_mount->m_flags & XFS_MOUNT_BARRIER) && changed) {
1185                 /*
1186                  * If the log write didn't issue an ordered tag we need
1187                  * to flush the disk cache for the data device now.
1188                  */
1189                 if (!log_flushed)
1190                         xfs_blkdev_issue_flush(ip->i_mount->m_ddev_targp);
1191
1192                 /*
1193                  * If this inode is on the RT dev we need to flush that
1194                  * cache as well.
1195                  */
1196                 if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME)
1197                         xfs_blkdev_issue_flush(ip->i_mount->m_rtdev_targp);
1198         }
1199
1200         return error;
1201 }
1202
1203 /*
1204  * This is called by xfs_inactive to free any blocks beyond eof,
1205  * when the link count isn't zero.
1206  */
1207 STATIC int
1208 xfs_inactive_free_eofblocks(
1209         xfs_mount_t     *mp,
1210         xfs_inode_t     *ip)
1211 {
1212         xfs_trans_t     *tp;
1213         int             error;
1214         xfs_fileoff_t   end_fsb;
1215         xfs_fileoff_t   last_fsb;
1216         xfs_filblks_t   map_len;
1217         int             nimaps;
1218         xfs_bmbt_irec_t imap;
1219
1220         /*
1221          * Figure out if there are any blocks beyond the end
1222          * of the file.  If not, then there is nothing to do.
1223          */
1224         end_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)ip->i_size));
1225         last_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1226         map_len = last_fsb - end_fsb;
1227         if (map_len <= 0)
1228                 return 0;
1229
1230         nimaps = 1;
1231         xfs_ilock(ip, XFS_ILOCK_SHARED);
1232         error = XFS_BMAPI(mp, NULL, &ip->i_iocore, end_fsb, map_len, 0,
1233                           NULL, 0, &imap, &nimaps, NULL, NULL);
1234         xfs_iunlock(ip, XFS_ILOCK_SHARED);
1235
1236         if (!error && (nimaps != 0) &&
1237             (imap.br_startblock != HOLESTARTBLOCK ||
1238              ip->i_delayed_blks)) {
1239                 /*
1240                  * Attach the dquots to the inode up front.
1241                  */
1242                 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
1243                         return error;
1244
1245                 /*
1246                  * There are blocks after the end of file.
1247                  * Free them up now by truncating the file to
1248                  * its current size.
1249                  */
1250                 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1251
1252                 /*
1253                  * Do the xfs_itruncate_start() call before
1254                  * reserving any log space because
1255                  * itruncate_start will call into the buffer
1256                  * cache and we can't
1257                  * do that within a transaction.
1258                  */
1259                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1260                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
1261                                     ip->i_size);
1262                 if (error) {
1263                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1264                         return error;
1265                 }
1266
1267                 error = xfs_trans_reserve(tp, 0,
1268                                           XFS_ITRUNCATE_LOG_RES(mp),
1269                                           0, XFS_TRANS_PERM_LOG_RES,
1270                                           XFS_ITRUNCATE_LOG_COUNT);
1271                 if (error) {
1272                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1273                         xfs_trans_cancel(tp, 0);
1274                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1275                         return error;
1276                 }
1277
1278                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1279                 xfs_trans_ijoin(tp, ip,
1280                                 XFS_IOLOCK_EXCL |
1281                                 XFS_ILOCK_EXCL);
1282                 xfs_trans_ihold(tp, ip);
1283
1284                 error = xfs_itruncate_finish(&tp, ip,
1285                                              ip->i_size,
1286                                              XFS_DATA_FORK,
1287                                              0);
1288                 /*
1289                  * If we get an error at this point we
1290                  * simply don't bother truncating the file.
1291                  */
1292                 if (error) {
1293                         xfs_trans_cancel(tp,
1294                                          (XFS_TRANS_RELEASE_LOG_RES |
1295                                           XFS_TRANS_ABORT));
1296                 } else {
1297                         error = xfs_trans_commit(tp,
1298                                                 XFS_TRANS_RELEASE_LOG_RES);
1299                 }
1300                 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1301         }
1302         return error;
1303 }
1304
1305 /*
1306  * Free a symlink that has blocks associated with it.
1307  */
1308 STATIC int
1309 xfs_inactive_symlink_rmt(
1310         xfs_inode_t     *ip,
1311         xfs_trans_t     **tpp)
1312 {
1313         xfs_buf_t       *bp;
1314         int             committed;
1315         int             done;
1316         int             error;
1317         xfs_fsblock_t   first_block;
1318         xfs_bmap_free_t free_list;
1319         int             i;
1320         xfs_mount_t     *mp;
1321         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
1322         int             nmaps;
1323         xfs_trans_t     *ntp;
1324         int             size;
1325         xfs_trans_t     *tp;
1326
1327         tp = *tpp;
1328         mp = ip->i_mount;
1329         ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
1330         /*
1331          * We're freeing a symlink that has some
1332          * blocks allocated to it.  Free the
1333          * blocks here.  We know that we've got
1334          * either 1 or 2 extents and that we can
1335          * free them all in one bunmapi call.
1336          */
1337         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
1338         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1339                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1340                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1341                 xfs_trans_cancel(tp, 0);
1342                 *tpp = NULL;
1343                 return error;
1344         }
1345         /*
1346          * Lock the inode, fix the size, and join it to the transaction.
1347          * Hold it so in the normal path, we still have it locked for
1348          * the second transaction.  In the error paths we need it
1349          * held so the cancel won't rele it, see below.
1350          */
1351         xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1352         size = (int)ip->i_d.di_size;
1353         ip->i_d.di_size = 0;
1354         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1355         xfs_trans_ihold(tp, ip);
1356         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1357         /*
1358          * Find the block(s) so we can inval and unmap them.
1359          */
1360         done = 0;
1361         XFS_BMAP_INIT(&free_list, &first_block);
1362         nmaps = ARRAY_SIZE(mval);
1363         if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
1364                         XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
1365                         &free_list, NULL)))
1366                 goto error0;
1367         /*
1368          * Invalidate the block(s).
1369          */
1370         for (i = 0; i < nmaps; i++) {
1371                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
1372                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
1373                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
1374                 xfs_trans_binval(tp, bp);
1375         }
1376         /*
1377          * Unmap the dead block(s) to the free_list.
1378          */
1379         if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
1380                         &first_block, &free_list, NULL, &done)))
1381                 goto error1;
1382         ASSERT(done);
1383         /*
1384          * Commit the first transaction.  This logs the EFI and the inode.
1385          */
1386         if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
1387                 goto error1;
1388         /*
1389          * The transaction must have been committed, since there were
1390          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
1391          * The new tp has the extent freeing and EFDs.
1392          */
1393         ASSERT(committed);
1394         /*
1395          * The first xact was committed, so add the inode to the new one.
1396          * Mark it dirty so it will be logged and moved forward in the log as
1397          * part of every commit.
1398          */
1399         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1400         xfs_trans_ihold(tp, ip);
1401         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1402         /*
1403          * Get a new, empty transaction to return to our caller.
1404          */
1405         ntp = xfs_trans_dup(tp);
1406         /*
1407          * Commit the transaction containing extent freeing and EFDs.
1408          * If we get an error on the commit here or on the reserve below,
1409          * we need to unlock the inode since the new transaction doesn't
1410          * have the inode attached.
1411          */
1412         error = xfs_trans_commit(tp, 0);
1413         tp = ntp;
1414         if (error) {
1415                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1416                 goto error0;
1417         }
1418         /*
1419          * Remove the memory for extent descriptions (just bookkeeping).
1420          */
1421         if (ip->i_df.if_bytes)
1422                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
1423         ASSERT(ip->i_df.if_bytes == 0);
1424         /*
1425          * Put an itruncate log reservation in the new transaction
1426          * for our caller.
1427          */
1428         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1429                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1430                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1431                 goto error0;
1432         }
1433         /*
1434          * Return with the inode locked but not joined to the transaction.
1435          */
1436         *tpp = tp;
1437         return 0;
1438
1439  error1:
1440         xfs_bmap_cancel(&free_list);
1441  error0:
1442         /*
1443          * Have to come here with the inode locked and either
1444          * (held and in the transaction) or (not in the transaction).
1445          * If the inode isn't held then cancel would iput it, but
1446          * that's wrong since this is inactive and the vnode ref
1447          * count is 0 already.
1448          * Cancel won't do anything to the inode if held, but it still
1449          * needs to be locked until the cancel is done, if it was
1450          * joined to the transaction.
1451          */
1452         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1453         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1454         *tpp = NULL;
1455         return error;
1456
1457 }
1458
1459 STATIC int
1460 xfs_inactive_symlink_local(
1461         xfs_inode_t     *ip,
1462         xfs_trans_t     **tpp)
1463 {
1464         int             error;
1465
1466         ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
1467         /*
1468          * We're freeing a symlink which fit into
1469          * the inode.  Just free the memory used
1470          * to hold the old symlink.
1471          */
1472         error = xfs_trans_reserve(*tpp, 0,
1473                                   XFS_ITRUNCATE_LOG_RES(ip->i_mount),
1474                                   0, XFS_TRANS_PERM_LOG_RES,
1475                                   XFS_ITRUNCATE_LOG_COUNT);
1476
1477         if (error) {
1478                 xfs_trans_cancel(*tpp, 0);
1479                 *tpp = NULL;
1480                 return error;
1481         }
1482         xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1483
1484         /*
1485          * Zero length symlinks _can_ exist.
1486          */
1487         if (ip->i_df.if_bytes > 0) {
1488                 xfs_idata_realloc(ip,
1489                                   -(ip->i_df.if_bytes),
1490                                   XFS_DATA_FORK);
1491                 ASSERT(ip->i_df.if_bytes == 0);
1492         }
1493         return 0;
1494 }
1495
1496 STATIC int
1497 xfs_inactive_attrs(
1498         xfs_inode_t     *ip,
1499         xfs_trans_t     **tpp)
1500 {
1501         xfs_trans_t     *tp;
1502         int             error;
1503         xfs_mount_t     *mp;
1504
1505         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
1506         tp = *tpp;
1507         mp = ip->i_mount;
1508         ASSERT(ip->i_d.di_forkoff != 0);
1509         xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1510         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1511
1512         error = xfs_attr_inactive(ip);
1513         if (error) {
1514                 *tpp = NULL;
1515                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1516                 return error; /* goto out */
1517         }
1518
1519         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1520         error = xfs_trans_reserve(tp, 0,
1521                                   XFS_IFREE_LOG_RES(mp),
1522                                   0, XFS_TRANS_PERM_LOG_RES,
1523                                   XFS_INACTIVE_LOG_COUNT);
1524         if (error) {
1525                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1526                 xfs_trans_cancel(tp, 0);
1527                 *tpp = NULL;
1528                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1529                 return error;
1530         }
1531
1532         xfs_ilock(ip, XFS_ILOCK_EXCL);
1533         xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1534         xfs_trans_ihold(tp, ip);
1535         xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1536
1537         ASSERT(ip->i_d.di_anextents == 0);
1538
1539         *tpp = tp;
1540         return 0;
1541 }
1542
1543 STATIC int
1544 xfs_release(
1545         bhv_desc_t      *bdp)
1546 {
1547         xfs_inode_t     *ip;
1548         bhv_vnode_t     *vp;
1549         xfs_mount_t     *mp;
1550         int             error;
1551
1552         vp = BHV_TO_VNODE(bdp);
1553         ip = XFS_BHVTOI(bdp);
1554         mp = ip->i_mount;
1555
1556         if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0))
1557                 return 0;
1558
1559         /* If this is a read-only mount, don't do this (would generate I/O) */
1560         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1561                 return 0;
1562
1563 #ifdef HAVE_REFCACHE
1564         /* If we are in the NFS reference cache then don't do this now */
1565         if (ip->i_refcache)
1566                 return 0;
1567 #endif
1568
1569         if (ip->i_d.di_nlink != 0) {
1570                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1571                      ((ip->i_size > 0) || (VN_CACHED(vp) > 0 ||
1572                        ip->i_delayed_blks > 0)) &&
1573                      (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
1574                     (!(ip->i_d.di_flags &
1575                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
1576                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
1577                                 return error;
1578                         /* Update linux inode block count after free above */
1579                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1580                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1581                 }
1582         }
1583
1584         return 0;
1585 }
1586
1587 /*
1588  * xfs_inactive
1589  *
1590  * This is called when the vnode reference count for the vnode
1591  * goes to zero.  If the file has been unlinked, then it must
1592  * now be truncated.  Also, we clear all of the read-ahead state
1593  * kept for the inode here since the file is now closed.
1594  */
1595 STATIC int
1596 xfs_inactive(
1597         bhv_desc_t      *bdp,
1598         cred_t          *credp)
1599 {
1600         xfs_inode_t     *ip;
1601         bhv_vnode_t     *vp;
1602         xfs_bmap_free_t free_list;
1603         xfs_fsblock_t   first_block;
1604         int             committed;
1605         xfs_trans_t     *tp;
1606         xfs_mount_t     *mp;
1607         int             error;
1608         int             truncate;
1609
1610         vp = BHV_TO_VNODE(bdp);
1611         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
1612
1613         ip = XFS_BHVTOI(bdp);
1614
1615         /*
1616          * If the inode is already free, then there can be nothing
1617          * to clean up here.
1618          */
1619         if (ip->i_d.di_mode == 0 || VN_BAD(vp)) {
1620                 ASSERT(ip->i_df.if_real_bytes == 0);
1621                 ASSERT(ip->i_df.if_broot_bytes == 0);
1622                 return VN_INACTIVE_CACHE;
1623         }
1624
1625         /*
1626          * Only do a truncate if it's a regular file with
1627          * some actual space in it.  It's OK to look at the
1628          * inode's fields without the lock because we're the
1629          * only one with a reference to the inode.
1630          */
1631         truncate = ((ip->i_d.di_nlink == 0) &&
1632             ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
1633              (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
1634             ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
1635
1636         mp = ip->i_mount;
1637
1638         if (ip->i_d.di_nlink == 0 &&
1639             DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_DESTROY)) {
1640                 (void) XFS_SEND_DESTROY(mp, vp, DM_RIGHT_NULL);
1641         }
1642
1643         error = 0;
1644
1645         /* If this is a read-only mount, don't do this (would generate I/O) */
1646         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1647                 goto out;
1648
1649         if (ip->i_d.di_nlink != 0) {
1650                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1651                      ((ip->i_size > 0) || (VN_CACHED(vp) > 0 ||
1652                        ip->i_delayed_blks > 0)) &&
1653                       (ip->i_df.if_flags & XFS_IFEXTENTS) &&
1654                      (!(ip->i_d.di_flags &
1655                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
1656                       (ip->i_delayed_blks != 0)))) {
1657                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
1658                                 return VN_INACTIVE_CACHE;
1659                         /* Update linux inode block count after free above */
1660                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1661                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1662                 }
1663                 goto out;
1664         }
1665
1666         ASSERT(ip->i_d.di_nlink == 0);
1667
1668         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
1669                 return VN_INACTIVE_CACHE;
1670
1671         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1672         if (truncate) {
1673                 /*
1674                  * Do the xfs_itruncate_start() call before
1675                  * reserving any log space because itruncate_start
1676                  * will call into the buffer cache and we can't
1677                  * do that within a transaction.
1678                  */
1679                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1680
1681                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
1682                 if (error) {
1683                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1684                         return VN_INACTIVE_CACHE;
1685                 }
1686
1687                 error = xfs_trans_reserve(tp, 0,
1688                                           XFS_ITRUNCATE_LOG_RES(mp),
1689                                           0, XFS_TRANS_PERM_LOG_RES,
1690                                           XFS_ITRUNCATE_LOG_COUNT);
1691                 if (error) {
1692                         /* Don't call itruncate_cleanup */
1693                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1694                         xfs_trans_cancel(tp, 0);
1695                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1696                         return VN_INACTIVE_CACHE;
1697                 }
1698
1699                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1700                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1701                 xfs_trans_ihold(tp, ip);
1702
1703                 /*
1704                  * normally, we have to run xfs_itruncate_finish sync.
1705                  * But if filesystem is wsync and we're in the inactive
1706                  * path, then we know that nlink == 0, and that the
1707                  * xaction that made nlink == 0 is permanently committed
1708                  * since xfs_remove runs as a synchronous transaction.
1709                  */
1710                 error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK,
1711                                 (!(mp->m_flags & XFS_MOUNT_WSYNC) ? 1 : 0));
1712
1713                 if (error) {
1714                         xfs_trans_cancel(tp,
1715                                 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1716                         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1717                         return VN_INACTIVE_CACHE;
1718                 }
1719         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
1720
1721                 /*
1722                  * If we get an error while cleaning up a
1723                  * symlink we bail out.
1724                  */
1725                 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
1726                         xfs_inactive_symlink_rmt(ip, &tp) :
1727                         xfs_inactive_symlink_local(ip, &tp);
1728
1729                 if (error) {
1730                         ASSERT(tp == NULL);
1731                         return VN_INACTIVE_CACHE;
1732                 }
1733
1734                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1735                 xfs_trans_ihold(tp, ip);
1736         } else {
1737                 error = xfs_trans_reserve(tp, 0,
1738                                           XFS_IFREE_LOG_RES(mp),
1739                                           0, XFS_TRANS_PERM_LOG_RES,
1740                                           XFS_INACTIVE_LOG_COUNT);
1741                 if (error) {
1742                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1743                         xfs_trans_cancel(tp, 0);
1744                         return VN_INACTIVE_CACHE;
1745                 }
1746
1747                 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1748                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1749                 xfs_trans_ihold(tp, ip);
1750         }
1751
1752         /*
1753          * If there are attributes associated with the file
1754          * then blow them away now.  The code calls a routine
1755          * that recursively deconstructs the attribute fork.
1756          * We need to just commit the current transaction
1757          * because we can't use it for xfs_attr_inactive().
1758          */
1759         if (ip->i_d.di_anextents > 0) {
1760                 error = xfs_inactive_attrs(ip, &tp);
1761                 /*
1762                  * If we got an error, the transaction is already
1763                  * cancelled, and the inode is unlocked. Just get out.
1764                  */
1765                  if (error)
1766                          return VN_INACTIVE_CACHE;
1767         } else if (ip->i_afp) {
1768                 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1769         }
1770
1771         /*
1772          * Free the inode.
1773          */
1774         XFS_BMAP_INIT(&free_list, &first_block);
1775         error = xfs_ifree(tp, ip, &free_list);
1776         if (error) {
1777                 /*
1778                  * If we fail to free the inode, shut down.  The cancel
1779                  * might do that, we need to make sure.  Otherwise the
1780                  * inode might be lost for a long time or forever.
1781                  */
1782                 if (!XFS_FORCED_SHUTDOWN(mp)) {
1783                         cmn_err(CE_NOTE,
1784                 "xfs_inactive:  xfs_ifree() returned an error = %d on %s",
1785                                 error, mp->m_fsname);
1786                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1787                 }
1788                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
1789         } else {
1790                 /*
1791                  * Credit the quota account(s). The inode is gone.
1792                  */
1793                 XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1794
1795                 /*
1796                  * Just ignore errors at this point.  There is
1797                  * nothing we can do except to try to keep going.
1798                  */
1799                 (void) xfs_bmap_finish(&tp,  &free_list, &committed);
1800                 (void) xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1801         }
1802         /*
1803          * Release the dquots held by inode, if any.
1804          */
1805         XFS_QM_DQDETACH(mp, ip);
1806
1807         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1808
1809  out:
1810         return VN_INACTIVE_CACHE;
1811 }
1812
1813
1814 /*
1815  * xfs_lookup
1816  */
1817 STATIC int
1818 xfs_lookup(
1819         bhv_desc_t              *dir_bdp,
1820         bhv_vname_t             *dentry,
1821         bhv_vnode_t             **vpp,
1822         int                     flags,
1823         bhv_vnode_t             *rdir,
1824         cred_t                  *credp)
1825 {
1826         xfs_inode_t             *dp, *ip;
1827         xfs_ino_t               e_inum;
1828         int                     error;
1829         uint                    lock_mode;
1830         bhv_vnode_t             *dir_vp;
1831
1832         dir_vp = BHV_TO_VNODE(dir_bdp);
1833         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1834
1835         dp = XFS_BHVTOI(dir_bdp);
1836
1837         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
1838                 return XFS_ERROR(EIO);
1839
1840         lock_mode = xfs_ilock_map_shared(dp);
1841         error = xfs_dir_lookup_int(dir_bdp, lock_mode, dentry, &e_inum, &ip);
1842         if (!error) {
1843                 *vpp = XFS_ITOV(ip);
1844                 ITRACE(ip);
1845         }
1846         xfs_iunlock_map_shared(dp, lock_mode);
1847         return error;
1848 }
1849
1850
1851 /*
1852  * xfs_create (create a new file).
1853  */
1854 STATIC int
1855 xfs_create(
1856         bhv_desc_t              *dir_bdp,
1857         bhv_vname_t             *dentry,
1858         bhv_vattr_t             *vap,
1859         bhv_vnode_t             **vpp,
1860         cred_t                  *credp)
1861 {
1862         char                    *name = VNAME(dentry);
1863         bhv_vnode_t             *dir_vp;
1864         xfs_inode_t             *dp, *ip;
1865         bhv_vnode_t             *vp = NULL;
1866         xfs_trans_t             *tp;
1867         xfs_mount_t             *mp;
1868         xfs_dev_t               rdev;
1869         int                     error;
1870         xfs_bmap_free_t         free_list;
1871         xfs_fsblock_t           first_block;
1872         boolean_t               dp_joined_to_trans;
1873         int                     dm_event_sent = 0;
1874         uint                    cancel_flags;
1875         int                     committed;
1876         xfs_prid_t              prid;
1877         struct xfs_dquot        *udqp, *gdqp;
1878         uint                    resblks;
1879         int                     dm_di_mode;
1880         int                     namelen;
1881
1882         ASSERT(!*vpp);
1883         dir_vp = BHV_TO_VNODE(dir_bdp);
1884         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1885
1886         dp = XFS_BHVTOI(dir_bdp);
1887         mp = dp->i_mount;
1888
1889         dm_di_mode = vap->va_mode;
1890         namelen = VNAMELEN(dentry);
1891
1892         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
1893                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
1894                                 dir_vp, DM_RIGHT_NULL, NULL,
1895                                 DM_RIGHT_NULL, name, NULL,
1896                                 dm_di_mode, 0, 0);
1897
1898                 if (error)
1899                         return error;
1900                 dm_event_sent = 1;
1901         }
1902
1903         if (XFS_FORCED_SHUTDOWN(mp))
1904                 return XFS_ERROR(EIO);
1905
1906         /* Return through std_return after this point. */
1907
1908         udqp = gdqp = NULL;
1909         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1910                 prid = dp->i_d.di_projid;
1911         else if (vap->va_mask & XFS_AT_PROJID)
1912                 prid = (xfs_prid_t)vap->va_projid;
1913         else
1914                 prid = (xfs_prid_t)dfltprid;
1915
1916         /*
1917          * Make sure that we have allocated dquot(s) on disk.
1918          */
1919         error = XFS_QM_DQVOPALLOC(mp, dp,
1920                         current_fsuid(credp), current_fsgid(credp), prid,
1921                         XFS_QMOPT_QUOTALL|XFS_QMOPT_INHERIT, &udqp, &gdqp);
1922         if (error)
1923                 goto std_return;
1924
1925         ip = NULL;
1926         dp_joined_to_trans = B_FALSE;
1927
1928         tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
1929         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1930         resblks = XFS_CREATE_SPACE_RES(mp, namelen);
1931         /*
1932          * Initially assume that the file does not exist and
1933          * reserve the resources for that case.  If that is not
1934          * the case we'll drop the one we have and get a more
1935          * appropriate transaction later.
1936          */
1937         error = xfs_trans_reserve(tp, resblks, XFS_CREATE_LOG_RES(mp), 0,
1938                         XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1939         if (error == ENOSPC) {
1940                 resblks = 0;
1941                 error = xfs_trans_reserve(tp, 0, XFS_CREATE_LOG_RES(mp), 0,
1942                                 XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1943         }
1944         if (error) {
1945                 cancel_flags = 0;
1946                 dp = NULL;
1947                 goto error_return;
1948         }
1949
1950         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1951
1952         XFS_BMAP_INIT(&free_list, &first_block);
1953
1954         ASSERT(ip == NULL);
1955
1956         /*
1957          * Reserve disk quota and the inode.
1958          */
1959         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
1960         if (error)
1961                 goto error_return;
1962
1963         if (resblks == 0 && (error = xfs_dir_canenter(tp, dp, name, namelen)))
1964                 goto error_return;
1965         rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
1966         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
1967                         rdev, credp, prid, resblks > 0,
1968                         &ip, &committed);
1969         if (error) {
1970                 if (error == ENOSPC)
1971                         goto error_return;
1972                 goto abort_return;
1973         }
1974         ITRACE(ip);
1975
1976         /*
1977          * At this point, we've gotten a newly allocated inode.
1978          * It is locked (and joined to the transaction).
1979          */
1980
1981         ASSERT(ismrlocked (&ip->i_lock, MR_UPDATE));
1982
1983         /*
1984          * Now we join the directory inode to the transaction.
1985          * We do not do it earlier because xfs_dir_ialloc
1986          * might commit the previous transaction (and release
1987          * all the locks).
1988          */
1989
1990         VN_HOLD(dir_vp);
1991         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1992         dp_joined_to_trans = B_TRUE;
1993
1994         error = xfs_dir_createname(tp, dp, name, namelen, ip->i_ino,
1995                                         &first_block, &free_list, resblks ?
1996                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1997         if (error) {
1998                 ASSERT(error != ENOSPC);
1999                 goto abort_return;
2000         }
2001         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2002         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2003
2004         /*
2005          * If this is a synchronous mount, make sure that the
2006          * create transaction goes to disk before returning to
2007          * the user.
2008          */
2009         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2010                 xfs_trans_set_sync(tp);
2011         }
2012
2013         dp->i_gen++;
2014
2015         /*
2016          * Attach the dquot(s) to the inodes and modify them incore.
2017          * These ids of the inode couldn't have changed since the new
2018          * inode has been locked ever since it was created.
2019          */
2020         XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
2021
2022         /*
2023          * xfs_trans_commit normally decrements the vnode ref count
2024          * when it unlocks the inode. Since we want to return the
2025          * vnode to the caller, we bump the vnode ref count now.
2026          */
2027         IHOLD(ip);
2028         vp = XFS_ITOV(ip);
2029
2030         error = xfs_bmap_finish(&tp, &free_list, &committed);
2031         if (error) {
2032                 xfs_bmap_cancel(&free_list);
2033                 goto abort_rele;
2034         }
2035
2036         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2037         if (error) {
2038                 IRELE(ip);
2039                 tp = NULL;
2040                 goto error_return;
2041         }
2042
2043         XFS_QM_DQRELE(mp, udqp);
2044         XFS_QM_DQRELE(mp, gdqp);
2045
2046         /*
2047          * Propagate the fact that the vnode changed after the
2048          * xfs_inode locks have been released.
2049          */
2050         bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
2051
2052         *vpp = vp;
2053
2054         /* Fallthrough to std_return with error = 0  */
2055
2056 std_return:
2057         if ( (*vpp || (error != 0 && dm_event_sent != 0)) &&
2058                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2059                                                         DM_EVENT_POSTCREATE)) {
2060                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2061                         dir_vp, DM_RIGHT_NULL,
2062                         *vpp ? vp:NULL,
2063                         DM_RIGHT_NULL, name, NULL,
2064                         dm_di_mode, error, 0);
2065         }
2066         return error;
2067
2068  abort_return:
2069         cancel_flags |= XFS_TRANS_ABORT;
2070         /* FALLTHROUGH */
2071
2072  error_return:
2073         if (tp != NULL)
2074                 xfs_trans_cancel(tp, cancel_flags);
2075
2076         if (!dp_joined_to_trans && (dp != NULL))
2077                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2078         XFS_QM_DQRELE(mp, udqp);
2079         XFS_QM_DQRELE(mp, gdqp);
2080
2081         goto std_return;
2082
2083  abort_rele:
2084         /*
2085          * Wait until after the current transaction is aborted to
2086          * release the inode.  This prevents recursive transactions
2087          * and deadlocks from xfs_inactive.
2088          */
2089         cancel_flags |= XFS_TRANS_ABORT;
2090         xfs_trans_cancel(tp, cancel_flags);
2091         IRELE(ip);
2092
2093         XFS_QM_DQRELE(mp, udqp);
2094         XFS_QM_DQRELE(mp, gdqp);
2095
2096         goto std_return;
2097 }
2098
2099 #ifdef DEBUG
2100 /*
2101  * Some counters to see if (and how often) we are hitting some deadlock
2102  * prevention code paths.
2103  */
2104
2105 int xfs_rm_locks;
2106 int xfs_rm_lock_delays;
2107 int xfs_rm_attempts;
2108 #endif
2109
2110 /*
2111  * The following routine will lock the inodes associated with the
2112  * directory and the named entry in the directory. The locks are
2113  * acquired in increasing inode number.
2114  *
2115  * If the entry is "..", then only the directory is locked. The
2116  * vnode ref count will still include that from the .. entry in
2117  * this case.
2118  *
2119  * There is a deadlock we need to worry about. If the locked directory is
2120  * in the AIL, it might be blocking up the log. The next inode we lock
2121  * could be already locked by another thread waiting for log space (e.g
2122  * a permanent log reservation with a long running transaction (see
2123  * xfs_itruncate_finish)). To solve this, we must check if the directory
2124  * is in the ail and use lock_nowait. If we can't lock, we need to
2125  * drop the inode lock on the directory and try again. xfs_iunlock will
2126  * potentially push the tail if we were holding up the log.
2127  */
2128 STATIC int
2129 xfs_lock_dir_and_entry(
2130         xfs_inode_t     *dp,
2131         xfs_inode_t     *ip)    /* inode of entry 'name' */
2132 {
2133         int             attempts;
2134         xfs_ino_t       e_inum;
2135         xfs_inode_t     *ips[2];
2136         xfs_log_item_t  *lp;
2137
2138 #ifdef DEBUG
2139         xfs_rm_locks++;
2140 #endif
2141         attempts = 0;
2142
2143 again:
2144         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
2145
2146         e_inum = ip->i_ino;
2147
2148         ITRACE(ip);
2149
2150         /*
2151          * We want to lock in increasing inum. Since we've already
2152          * acquired the lock on the directory, we may need to release
2153          * if if the inum of the entry turns out to be less.
2154          */
2155         if (e_inum > dp->i_ino) {
2156                 /*
2157                  * We are already in the right order, so just
2158                  * lock on the inode of the entry.
2159                  * We need to use nowait if dp is in the AIL.
2160                  */
2161
2162                 lp = (xfs_log_item_t *)dp->i_itemp;
2163                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2164                         if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2165                                 attempts++;
2166 #ifdef DEBUG
2167                                 xfs_rm_attempts++;
2168 #endif
2169
2170                                 /*
2171                                  * Unlock dp and try again.
2172                                  * xfs_iunlock will try to push the tail
2173                                  * if the inode is in the AIL.
2174                                  */
2175
2176                                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2177
2178                                 if ((attempts % 5) == 0) {
2179                                         delay(1); /* Don't just spin the CPU */
2180 #ifdef DEBUG
2181                                         xfs_rm_lock_delays++;
2182 #endif
2183                                 }
2184                                 goto again;
2185                         }
2186                 } else {
2187                         xfs_ilock(ip, XFS_ILOCK_EXCL);
2188                 }
2189         } else if (e_inum < dp->i_ino) {
2190                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2191
2192                 ips[0] = ip;
2193                 ips[1] = dp;
2194                 xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2195         }
2196         /* else  e_inum == dp->i_ino */
2197         /*     This can happen if we're asked to lock /x/..
2198          *     the entry is "..", which is also the parent directory.
2199          */
2200
2201         return 0;
2202 }
2203
2204 #ifdef DEBUG
2205 int xfs_locked_n;
2206 int xfs_small_retries;
2207 int xfs_middle_retries;
2208 int xfs_lots_retries;
2209 int xfs_lock_delays;
2210 #endif
2211
2212 /*
2213  * Bump the subclass so xfs_lock_inodes() acquires each lock with
2214  * a different value
2215  */
2216 static inline int
2217 xfs_lock_inumorder(int lock_mode, int subclass)
2218 {
2219         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
2220                 lock_mode |= (subclass + XFS_IOLOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
2221         if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
2222                 lock_mode |= (subclass + XFS_ILOCK_INUMORDER) << XFS_ILOCK_SHIFT;
2223
2224         return lock_mode;
2225 }
2226
2227 /*
2228  * The following routine will lock n inodes in exclusive mode.
2229  * We assume the caller calls us with the inodes in i_ino order.
2230  *
2231  * We need to detect deadlock where an inode that we lock
2232  * is in the AIL and we start waiting for another inode that is locked
2233  * by a thread in a long running transaction (such as truncate). This can
2234  * result in deadlock since the long running trans might need to wait
2235  * for the inode we just locked in order to push the tail and free space
2236  * in the log.
2237  */
2238 void
2239 xfs_lock_inodes(
2240         xfs_inode_t     **ips,
2241         int             inodes,
2242         int             first_locked,
2243         uint            lock_mode)
2244 {
2245         int             attempts = 0, i, j, try_lock;
2246         xfs_log_item_t  *lp;
2247
2248         ASSERT(ips && (inodes >= 2)); /* we need at least two */
2249
2250         if (first_locked) {
2251                 try_lock = 1;
2252                 i = 1;
2253         } else {
2254                 try_lock = 0;
2255                 i = 0;
2256         }
2257
2258 again:
2259         for (; i < inodes; i++) {
2260                 ASSERT(ips[i]);
2261
2262                 if (i && (ips[i] == ips[i-1]))  /* Already locked */
2263                         continue;
2264
2265                 /*
2266                  * If try_lock is not set yet, make sure all locked inodes
2267                  * are not in the AIL.
2268                  * If any are, set try_lock to be used later.
2269                  */
2270
2271                 if (!try_lock) {
2272                         for (j = (i - 1); j >= 0 && !try_lock; j--) {
2273                                 lp = (xfs_log_item_t *)ips[j]->i_itemp;
2274                                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2275                                         try_lock++;
2276                                 }
2277                         }
2278                 }
2279
2280                 /*
2281                  * If any of the previous locks we have locked is in the AIL,
2282                  * we must TRY to get the second and subsequent locks. If
2283                  * we can't get any, we must release all we have
2284                  * and try again.
2285                  */
2286
2287                 if (try_lock) {
2288                         /* try_lock must be 0 if i is 0. */
2289                         /*
2290                          * try_lock means we have an inode locked
2291                          * that is in the AIL.
2292                          */
2293                         ASSERT(i != 0);
2294                         if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
2295                                 attempts++;
2296
2297                                 /*
2298                                  * Unlock all previous guys and try again.
2299                                  * xfs_iunlock will try to push the tail
2300                                  * if the inode is in the AIL.
2301                                  */
2302
2303                                 for(j = i - 1; j >= 0; j--) {
2304
2305                                         /*
2306                                          * Check to see if we've already
2307                                          * unlocked this one.
2308                                          * Not the first one going back,
2309                                          * and the inode ptr is the same.
2310                                          */
2311                                         if ((j != (i - 1)) && ips[j] ==
2312                                                                 ips[j+1])
2313                                                 continue;
2314
2315                                         xfs_iunlock(ips[j], lock_mode);
2316                                 }
2317
2318                                 if ((attempts % 5) == 0) {
2319                                         delay(1); /* Don't just spin the CPU */
2320 #ifdef DEBUG
2321                                         xfs_lock_delays++;
2322 #endif
2323                                 }
2324                                 i = 0;
2325                                 try_lock = 0;
2326                                 goto again;
2327                         }
2328                 } else {
2329                         xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
2330                 }
2331         }
2332
2333 #ifdef DEBUG
2334         if (attempts) {
2335                 if (attempts < 5) xfs_small_retries++;
2336                 else if (attempts < 100) xfs_middle_retries++;
2337                 else xfs_lots_retries++;
2338         } else {
2339                 xfs_locked_n++;
2340         }
2341 #endif
2342 }
2343
2344 #ifdef  DEBUG
2345 #define REMOVE_DEBUG_TRACE(x)   {remove_which_error_return = (x);}
2346 int remove_which_error_return = 0;
2347 #else /* ! DEBUG */
2348 #define REMOVE_DEBUG_TRACE(x)
2349 #endif  /* ! DEBUG */
2350
2351
2352 /*
2353  * xfs_remove
2354  *
2355  */
2356 STATIC int
2357 xfs_remove(
2358         bhv_desc_t              *dir_bdp,
2359         bhv_vname_t             *dentry,
2360         cred_t                  *credp)
2361 {
2362         bhv_vnode_t             *dir_vp;
2363         char                    *name = VNAME(dentry);
2364         xfs_inode_t             *dp, *ip;
2365         xfs_trans_t             *tp = NULL;
2366         xfs_mount_t             *mp;
2367         int                     error = 0;
2368         xfs_bmap_free_t         free_list;
2369         xfs_fsblock_t           first_block;
2370         int                     cancel_flags;
2371         int                     committed;
2372         int                     dm_di_mode = 0;
2373         int                     link_zero;
2374         uint                    resblks;
2375         int                     namelen;
2376
2377         dir_vp = BHV_TO_VNODE(dir_bdp);
2378         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2379
2380         dp = XFS_BHVTOI(dir_bdp);
2381         mp = dp->i_mount;
2382
2383         if (XFS_FORCED_SHUTDOWN(mp))
2384                 return XFS_ERROR(EIO);
2385
2386         namelen = VNAMELEN(dentry);
2387
2388         if (!xfs_get_dir_entry(dentry, &ip)) {
2389                 dm_di_mode = ip->i_d.di_mode;
2390                 IRELE(ip);
2391         }
2392
2393         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
2394                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE, dir_vp,
2395                                         DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
2396                                         name, NULL, dm_di_mode, 0, 0);
2397                 if (error)
2398                         return error;
2399         }
2400
2401         /* From this point on, return through std_return */
2402         ip = NULL;
2403
2404         /*
2405          * We need to get a reference to ip before we get our log
2406          * reservation. The reason for this is that we cannot call
2407          * xfs_iget for an inode for which we do not have a reference
2408          * once we've acquired a log reservation. This is because the
2409          * inode we are trying to get might be in xfs_inactive going
2410          * for a log reservation. Since we'll have to wait for the
2411          * inactive code to complete before returning from xfs_iget,
2412          * we need to make sure that we don't have log space reserved
2413          * when we call xfs_iget.  Instead we get an unlocked reference
2414          * to the inode before getting our log reservation.
2415          */
2416         error = xfs_get_dir_entry(dentry, &ip);
2417         if (error) {
2418                 REMOVE_DEBUG_TRACE(__LINE__);
2419                 goto std_return;
2420         }
2421
2422         dm_di_mode = ip->i_d.di_mode;
2423
2424         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2425
2426         ITRACE(ip);
2427
2428         error = XFS_QM_DQATTACH(mp, dp, 0);
2429         if (!error && dp != ip)
2430                 error = XFS_QM_DQATTACH(mp, ip, 0);
2431         if (error) {
2432                 REMOVE_DEBUG_TRACE(__LINE__);
2433                 IRELE(ip);
2434                 goto std_return;
2435         }
2436
2437         tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
2438         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2439         /*
2440          * We try to get the real space reservation first,
2441          * allowing for directory btree deletion(s) implying
2442          * possible bmap insert(s).  If we can't get the space
2443          * reservation then we use 0 instead, and avoid the bmap
2444          * btree insert(s) in the directory code by, if the bmap
2445          * insert tries to happen, instead trimming the LAST
2446          * block from the directory.
2447          */
2448         resblks = XFS_REMOVE_SPACE_RES(mp);
2449         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
2450                         XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2451         if (error == ENOSPC) {
2452                 resblks = 0;
2453                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
2454                                 XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2455         }
2456         if (error) {
2457                 ASSERT(error != ENOSPC);
2458                 REMOVE_DEBUG_TRACE(__LINE__);
2459                 xfs_trans_cancel(tp, 0);
2460                 IRELE(ip);
2461                 return error;
2462         }
2463
2464         error = xfs_lock_dir_and_entry(dp, ip);
2465         if (error) {
2466                 REMOVE_DEBUG_TRACE(__LINE__);
2467                 xfs_trans_cancel(tp, cancel_flags);
2468                 IRELE(ip);
2469                 goto std_return;
2470         }
2471
2472         /*
2473          * At this point, we've gotten both the directory and the entry
2474          * inodes locked.
2475          */
2476         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2477         if (dp != ip) {
2478                 /*
2479                  * Increment vnode ref count only in this case since
2480                  * there's an extra vnode reference in the case where
2481                  * dp == ip.
2482                  */
2483                 IHOLD(dp);
2484                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2485         }
2486
2487         /*
2488          * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2489          */
2490         XFS_BMAP_INIT(&free_list, &first_block);
2491         error = xfs_dir_removename(tp, dp, name, namelen, ip->i_ino,
2492                                         &first_block, &free_list, 0);
2493         if (error) {
2494                 ASSERT(error != ENOENT);
2495                 REMOVE_DEBUG_TRACE(__LINE__);
2496                 goto error1;
2497         }
2498         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2499
2500         dp->i_gen++;
2501         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2502
2503         error = xfs_droplink(tp, ip);
2504         if (error) {
2505                 REMOVE_DEBUG_TRACE(__LINE__);
2506                 goto error1;
2507         }
2508
2509         /* Determine if this is the last link while
2510          * we are in the transaction.
2511          */
2512         link_zero = (ip)->i_d.di_nlink==0;
2513
2514         /*
2515          * Take an extra ref on the inode so that it doesn't
2516          * go to xfs_inactive() from within the commit.
2517          */
2518         IHOLD(ip);
2519
2520         /*
2521          * If this is a synchronous mount, make sure that the
2522          * remove transaction goes to disk before returning to
2523          * the user.
2524          */
2525         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2526                 xfs_trans_set_sync(tp);
2527         }
2528
2529         error = xfs_bmap_finish(&tp, &free_list, &committed);
2530         if (error) {
2531                 REMOVE_DEBUG_TRACE(__LINE__);
2532                 goto error_rele;
2533         }
2534
2535         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2536         if (error) {
2537                 IRELE(ip);
2538                 goto std_return;
2539         }
2540
2541         /*
2542          * Before we drop our extra reference to the inode, purge it
2543          * from the refcache if it is there.  By waiting until afterwards
2544          * to do the IRELE, we ensure that we won't go inactive in the
2545          * xfs_refcache_purge_ip routine (although that would be OK).
2546          */
2547         xfs_refcache_purge_ip(ip);
2548
2549         vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2550
2551         /*
2552          * Let interposed file systems know about removed links.
2553          */
2554         bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
2555
2556         IRELE(ip);
2557
2558 /*      Fall through to std_return with error = 0 */
2559  std_return:
2560         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp,
2561                                                 DM_EVENT_POSTREMOVE)) {
2562                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
2563                                 dir_vp, DM_RIGHT_NULL,
2564                                 NULL, DM_RIGHT_NULL,
2565                                 name, NULL, dm_di_mode, error, 0);
2566         }
2567         return error;
2568
2569  error1:
2570         xfs_bmap_cancel(&free_list);
2571         cancel_flags |= XFS_TRANS_ABORT;
2572         xfs_trans_cancel(tp, cancel_flags);
2573         goto std_return;
2574
2575  error_rele:
2576         /*
2577          * In this case make sure to not release the inode until after
2578          * the current transaction is aborted.  Releasing it beforehand
2579          * can cause us to go to xfs_inactive and start a recursive
2580          * transaction which can easily deadlock with the current one.
2581          */
2582         xfs_bmap_cancel(&free_list);
2583         cancel_flags |= XFS_TRANS_ABORT;
2584         xfs_trans_cancel(tp, cancel_flags);
2585
2586         /*
2587          * Before we drop our extra reference to the inode, purge it
2588          * from the refcache if it is there.  By waiting until afterwards
2589          * to do the IRELE, we ensure that we won't go inactive in the
2590          * xfs_refcache_purge_ip routine (although that would be OK).
2591          */
2592         xfs_refcache_purge_ip(ip);
2593
2594         IRELE(ip);
2595
2596         goto std_return;
2597 }
2598
2599
2600 /*
2601  * xfs_link
2602  *
2603  */
2604 STATIC int
2605 xfs_link(
2606         bhv_desc_t              *target_dir_bdp,
2607         bhv_vnode_t             *src_vp,
2608         bhv_vname_t             *dentry,
2609         cred_t                  *credp)
2610 {
2611         xfs_inode_t             *tdp, *sip;
2612         xfs_trans_t             *tp;
2613         xfs_mount_t             *mp;
2614         xfs_inode_t             *ips[2];
2615         int                     error;
2616         xfs_bmap_free_t         free_list;
2617         xfs_fsblock_t           first_block;
2618         int                     cancel_flags;
2619         int                     committed;
2620         bhv_vnode_t             *target_dir_vp;
2621         int                     resblks;
2622         char                    *target_name = VNAME(dentry);
2623         int                     target_namelen;
2624
2625         target_dir_vp = BHV_TO_VNODE(target_dir_bdp);
2626         vn_trace_entry(target_dir_vp, __FUNCTION__, (inst_t *)__return_address);
2627         vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address);
2628
2629         target_namelen = VNAMELEN(dentry);
2630         ASSERT(!VN_ISDIR(src_vp));
2631
2632         sip = xfs_vtoi(src_vp);
2633         tdp = XFS_BHVTOI(target_dir_bdp);
2634         mp = tdp->i_mount;
2635         if (XFS_FORCED_SHUTDOWN(mp))
2636                 return XFS_ERROR(EIO);
2637
2638         if (DM_EVENT_ENABLED(src_vp->v_vfsp, tdp, DM_EVENT_LINK)) {
2639                 error = XFS_SEND_NAMESP(mp, DM_EVENT_LINK,
2640                                         target_dir_vp, DM_RIGHT_NULL,
2641                                         src_vp, DM_RIGHT_NULL,
2642                                         target_name, NULL, 0, 0, 0);
2643                 if (error)
2644                         return error;
2645         }
2646
2647         /* Return through std_return after this point. */
2648
2649         error = XFS_QM_DQATTACH(mp, sip, 0);
2650         if (!error && sip != tdp)
2651                 error = XFS_QM_DQATTACH(mp, tdp, 0);
2652         if (error)
2653                 goto std_return;
2654
2655         tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
2656         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2657         resblks = XFS_LINK_SPACE_RES(mp, target_namelen);
2658         error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
2659                         XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2660         if (error == ENOSPC) {
2661                 resblks = 0;
2662                 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
2663                                 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2664         }
2665         if (error) {
2666                 cancel_flags = 0;
2667                 goto error_return;
2668         }
2669
2670         if (sip->i_ino < tdp->i_ino) {
2671                 ips[0] = sip;
2672                 ips[1] = tdp;
2673         } else {
2674                 ips[0] = tdp;
2675                 ips[1] = sip;
2676         }
2677
2678         xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2679
2680         /*
2681          * Increment vnode ref counts since xfs_trans_commit &
2682          * xfs_trans_cancel will both unlock the inodes and
2683          * decrement the associated ref counts.
2684          */
2685         VN_HOLD(src_vp);
2686         VN_HOLD(target_dir_vp);
2687         xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
2688         xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
2689
2690         /*
2691          * If the source has too many links, we can't make any more to it.
2692          */
2693         if (sip->i_d.di_nlink >= XFS_MAXLINK) {
2694                 error = XFS_ERROR(EMLINK);
2695                 goto error_return;
2696         }
2697
2698         /*
2699          * If we are using project inheritance, we only allow hard link
2700          * creation in our tree when the project IDs are the same; else
2701          * the tree quota mechanism could be circumvented.
2702          */
2703         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
2704                      (tdp->i_d.di_projid != sip->i_d.di_projid))) {
2705                 error = XFS_ERROR(EXDEV);
2706                 goto error_return;
2707         }
2708
2709         if (resblks == 0 &&
2710             (error = xfs_dir_canenter(tp, tdp, target_name, target_namelen)))
2711                 goto error_return;
2712
2713         XFS_BMAP_INIT(&free_list, &first_block);
2714
2715         error = xfs_dir_createname(tp, tdp, target_name, target_namelen,
2716                                    sip->i_ino, &first_block, &free_list,
2717                                    resblks);
2718         if (error)
2719                 goto abort_return;
2720         xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2721         tdp->i_gen++;
2722         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
2723
2724         error = xfs_bumplink(tp, sip);
2725         if (error)
2726                 goto abort_return;
2727
2728         /*
2729          * If this is a synchronous mount, make sure that the
2730          * link transaction goes to disk before returning to
2731          * the user.
2732          */
2733         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2734                 xfs_trans_set_sync(tp);
2735         }
2736
2737         error = xfs_bmap_finish (&tp, &free_list, &committed);
2738         if (error) {
2739                 xfs_bmap_cancel(&free_list);
2740                 goto abort_return;
2741         }
2742
2743         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2744         if (error)
2745                 goto std_return;
2746
2747         /* Fall through to std_return with error = 0. */
2748 std_return:
2749         if (DM_EVENT_ENABLED(src_vp->v_vfsp, sip,
2750                                                 DM_EVENT_POSTLINK)) {
2751                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTLINK,
2752                                 target_dir_vp, DM_RIGHT_NULL,
2753                                 src_vp, DM_RIGHT_NULL,
2754                                 target_name, NULL, 0, error, 0);
2755         }
2756         return error;
2757
2758  abort_return:
2759         cancel_flags |= XFS_TRANS_ABORT;
2760         /* FALLTHROUGH */
2761
2762  error_return:
2763         xfs_trans_cancel(tp, cancel_flags);
2764         goto std_return;
2765 }
2766
2767
2768 /*
2769  * xfs_mkdir
2770  *
2771  */
2772 STATIC int
2773 xfs_mkdir(
2774         bhv_desc_t              *dir_bdp,
2775         bhv_vname_t             *dentry,
2776         bhv_vattr_t             *vap,
2777         bhv_vnode_t             **vpp,
2778         cred_t                  *credp)
2779 {
2780         char                    *dir_name = VNAME(dentry);
2781         xfs_inode_t             *dp;
2782         xfs_inode_t             *cdp;   /* inode of created dir */
2783         bhv_vnode_t             *cvp;   /* vnode of created dir */
2784         xfs_trans_t             *tp;
2785         xfs_mount_t             *mp;
2786         int                     cancel_flags;
2787         int                     error;
2788         int                     committed;
2789         xfs_bmap_free_t         free_list;
2790         xfs_fsblock_t           first_block;
2791         bhv_vnode_t             *dir_vp;
2792         boolean_t               dp_joined_to_trans;
2793         boolean_t               created = B_FALSE;
2794         int                     dm_event_sent = 0;
2795         xfs_prid_t              prid;
2796         struct xfs_dquot        *udqp, *gdqp;
2797         uint                    resblks;
2798         int                     dm_di_mode;
2799         int                     dir_namelen;
2800
2801         dir_vp = BHV_TO_VNODE(dir_bdp);
2802         dp = XFS_BHVTOI(dir_bdp);
2803         mp = dp->i_mount;
2804
2805         if (XFS_FORCED_SHUTDOWN(mp))
2806                 return XFS_ERROR(EIO);
2807
2808         dir_namelen = VNAMELEN(dentry);
2809
2810         tp = NULL;
2811         dp_joined_to_trans = B_FALSE;
2812         dm_di_mode = vap->va_mode;
2813
2814         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
2815                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
2816                                         dir_vp, DM_RIGHT_NULL, NULL,
2817                                         DM_RIGHT_NULL, dir_name, NULL,
2818                                         dm_di_mode, 0, 0);
2819                 if (error)
2820                         return error;
2821                 dm_event_sent = 1;
2822         }
2823
2824         /* Return through std_return after this point. */
2825
2826         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2827
2828         mp = dp->i_mount;
2829         udqp = gdqp = NULL;
2830         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
2831                 prid = dp->i_d.di_projid;
2832         else if (vap->va_mask & XFS_AT_PROJID)
2833                 prid = (xfs_prid_t)vap->va_projid;
2834         else
2835                 prid = (xfs_prid_t)dfltprid;
2836
2837         /*
2838          * Make sure that we have allocated dquot(s) on disk.
2839          */
2840         error = XFS_QM_DQVOPALLOC(mp, dp,
2841                         current_fsuid(credp), current_fsgid(credp), prid,
2842                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
2843         if (error)
2844                 goto std_return;
2845
2846         tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
2847         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2848         resblks = XFS_MKDIR_SPACE_RES(mp, dir_namelen);
2849         error = xfs_trans_reserve(tp, resblks, XFS_MKDIR_LOG_RES(mp), 0,
2850                                   XFS_TRANS_PERM_LOG_RES, XFS_MKDIR_LOG_COUNT);
2851         if (error == ENOSPC) {
2852                 resblks = 0;
2853                 error = xfs_trans_reserve(tp, 0, XFS_MKDIR_LOG_RES(mp), 0,
2854                                           XFS_TRANS_PERM_LOG_RES,
2855                                           XFS_MKDIR_LOG_COUNT);
2856         }
2857         if (error) {
2858                 cancel_flags = 0;
2859                 dp = NULL;
2860                 goto error_return;
2861         }
2862
2863         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
2864
2865         /*
2866          * Check for directory link count overflow.
2867          */
2868         if (dp->i_d.di_nlink >= XFS_MAXLINK) {
2869                 error = XFS_ERROR(EMLINK);
2870                 goto error_return;
2871         }
2872
2873         /*
2874          * Reserve disk quota and the inode.
2875          */
2876         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
2877         if (error)
2878                 goto error_return;
2879
2880         if (resblks == 0 &&
2881             (error = xfs_dir_canenter(tp, dp, dir_name, dir_namelen)))
2882                 goto error_return;
2883         /*
2884          * create the directory inode.
2885          */
2886         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 2,
2887                         0, credp, prid, resblks > 0,
2888                 &cdp, NULL);
2889         if (error) {
2890                 if (error == ENOSPC)
2891                         goto error_return;
2892                 goto abort_return;
2893         }
2894         ITRACE(cdp);
2895
2896         /*
2897          * Now we add the directory inode to the transaction.
2898          * We waited until now since xfs_dir_ialloc might start
2899          * a new transaction.  Had we joined the transaction
2900          * earlier, the locks might have gotten released.
2901          */
2902         VN_HOLD(dir_vp);
2903         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2904         dp_joined_to_trans = B_TRUE;
2905
2906         XFS_BMAP_INIT(&free_list, &first_block);
2907
2908         error = xfs_dir_createname(tp, dp, dir_name, dir_namelen, cdp->i_ino,
2909                                    &first_block, &free_list, resblks ?
2910                                    resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
2911         if (error) {
2912                 ASSERT(error != ENOSPC);
2913                 goto error1;
2914         }
2915         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2916
2917         /*
2918          * Bump the in memory version number of the parent directory
2919          * so that other processes accessing it will recognize that
2920          * the directory has changed.
2921          */
2922         dp->i_gen++;
2923
2924         error = xfs_dir_init(tp, cdp, dp);
2925         if (error)
2926                 goto error2;
2927
2928         cdp->i_gen = 1;
2929         error = xfs_bumplink(tp, dp);
2930         if (error)
2931                 goto error2;
2932
2933         cvp = XFS_ITOV(cdp);
2934
2935         created = B_TRUE;
2936
2937         *vpp = cvp;
2938         IHOLD(cdp);
2939
2940         /*
2941          * Attach the dquots to the new inode and modify the icount incore.
2942          */
2943         XFS_QM_DQVOPCREATE(mp, tp, cdp, udqp, gdqp);
2944
2945         /*
2946          * If this is a synchronous mount, make sure that the
2947          * mkdir transaction goes to disk before returning to
2948          * the user.
2949          */
2950         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2951                 xfs_trans_set_sync(tp);
2952         }
2953
2954         error = xfs_bmap_finish(&tp, &free_list, &committed);
2955         if (error) {
2956                 IRELE(cdp);
2957                 goto error2;
2958         }
2959
2960         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2961         XFS_QM_DQRELE(mp, udqp);
2962         XFS_QM_DQRELE(mp, gdqp);
2963         if (error) {
2964                 IRELE(cdp);
2965         }
2966
2967         /* Fall through to std_return with error = 0 or errno from
2968          * xfs_trans_commit. */
2969
2970 std_return:
2971         if ( (created || (error != 0 && dm_event_sent != 0)) &&
2972                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2973                                                 DM_EVENT_POSTCREATE)) {
2974                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2975                                         dir_vp, DM_RIGHT_NULL,
2976                                         created ? XFS_ITOV(cdp):NULL,
2977                                         DM_RIGHT_NULL,
2978                                         dir_name, NULL,
2979                                         dm_di_mode, error, 0);
2980         }
2981         return error;
2982
2983  error2:
2984  error1:
2985         xfs_bmap_cancel(&free_list);
2986  abort_return:
2987         cancel_flags |= XFS_TRANS_ABORT;
2988  error_return:
2989         xfs_trans_cancel(tp, cancel_flags);
2990         XFS_QM_DQRELE(mp, udqp);
2991         XFS_QM_DQRELE(mp, gdqp);
2992
2993         if (!dp_joined_to_trans && (dp != NULL)) {
2994                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2995         }
2996
2997         goto std_return;
2998 }
2999
3000
3001 /*
3002  * xfs_rmdir
3003  *
3004  */
3005 STATIC int
3006 xfs_rmdir(
3007         bhv_desc_t              *dir_bdp,
3008         bhv_vname_t             *dentry,
3009         cred_t                  *credp)
3010 {
3011         char                    *name = VNAME(dentry);
3012         xfs_inode_t             *dp;
3013         xfs_inode_t             *cdp;   /* child directory */
3014         xfs_trans_t             *tp;
3015         xfs_mount_t             *mp;
3016         int                     error;
3017         xfs_bmap_free_t         free_list;
3018         xfs_fsblock_t           first_block;
3019         int                     cancel_flags;
3020         int                     committed;
3021         bhv_vnode_t             *dir_vp;
3022         int                     dm_di_mode = S_IFDIR;
3023         int                     last_cdp_link;
3024         int                     namelen;
3025         uint                    resblks;
3026
3027         dir_vp = BHV_TO_VNODE(dir_bdp);
3028         dp = XFS_BHVTOI(dir_bdp);
3029         mp = dp->i_mount;
3030
3031         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
3032
3033         if (XFS_FORCED_SHUTDOWN(XFS_BHVTOI(dir_bdp)->i_mount))
3034                 return XFS_ERROR(EIO);
3035         namelen = VNAMELEN(dentry);
3036
3037         if (!xfs_get_dir_entry(dentry, &cdp)) {
3038                 dm_di_mode = cdp->i_d.di_mode;
3039                 IRELE(cdp);
3040         }
3041
3042         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
3043                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE,
3044                                         dir_vp, DM_RIGHT_NULL,
3045                                         NULL, DM_RIGHT_NULL,
3046                                         name, NULL, dm_di_mode, 0, 0);
3047                 if (error)
3048                         return XFS_ERROR(error);
3049         }
3050
3051         /* Return through std_return after this point. */
3052
3053         cdp = NULL;
3054
3055         /*
3056          * We need to get a reference to cdp before we get our log
3057          * reservation.  The reason for this is that we cannot call
3058          * xfs_iget for an inode for which we do not have a reference
3059          * once we've acquired a log reservation.  This is because the
3060          * inode we are trying to get might be in xfs_inactive going
3061          * for a log reservation.  Since we'll have to wait for the
3062          * inactive code to complete before returning from xfs_iget,
3063          * we need to make sure that we don't have log space reserved
3064          * when we call xfs_iget.  Instead we get an unlocked reference
3065          * to the inode before getting our log reservation.
3066          */
3067         error = xfs_get_dir_entry(dentry, &cdp);
3068         if (error) {
3069                 REMOVE_DEBUG_TRACE(__LINE__);
3070                 goto std_return;
3071         }
3072         mp = dp->i_mount;
3073         dm_di_mode = cdp->i_d.di_mode;
3074
3075         /*
3076          * Get the dquots for the inodes.
3077          */
3078         error = XFS_QM_DQATTACH(mp, dp, 0);
3079         if (!error && dp != cdp)
3080                 error = XFS_QM_DQATTACH(mp, cdp, 0);
3081         if (error) {
3082                 IRELE(cdp);
3083                 REMOVE_DEBUG_TRACE(__LINE__);
3084                 goto std_return;
3085         }
3086
3087         tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
3088         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
3089         /*
3090          * We try to get the real space reservation first,
3091          * allowing for directory btree deletion(s) implying
3092          * possible bmap insert(s).  If we can't get the space
3093          * reservation then we use 0 instead, and avoid the bmap
3094          * btree insert(s) in the directory code by, if the bmap
3095          * insert tries to happen, instead trimming the LAST
3096          * block from the directory.
3097          */
3098         resblks = XFS_REMOVE_SPACE_RES(mp);
3099         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
3100                         XFS_TRANS_PERM_LOG_RES, XFS_DEFAULT_LOG_COUNT);
3101         if (error == ENOSPC) {
3102                 resblks = 0;
3103                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
3104                                 XFS_TRANS_PERM_LOG_RES, XFS_DEFAULT_LOG_COUNT);
3105         }
3106         if (error) {
3107                 ASSERT(error != ENOSPC);
3108                 cancel_flags = 0;
3109                 IRELE(cdp);
3110                 goto error_return;
3111         }
3112         XFS_BMAP_INIT(&free_list, &first_block);
3113
3114         /*
3115          * Now lock the child directory inode and the parent directory
3116          * inode in the proper order.  This will take care of validating
3117          * that the directory entry for the child directory inode has
3118          * not changed while we were obtaining a log reservation.
3119          */
3120         error = xfs_lock_dir_and_entry(dp, cdp);
3121         if (error) {
3122                 xfs_trans_cancel(tp, cancel_flags);
3123                 IRELE(cdp);
3124                 goto std_return;
3125         }
3126
3127         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
3128         if (dp != cdp) {
3129                 /*
3130                  * Only increment the parent directory vnode count if
3131                  * we didn't bump it in looking up cdp.  The only time
3132                  * we don't bump it is when we're looking up ".".
3133                  */
3134                 VN_HOLD(dir_vp);
3135         }
3136
3137         ITRACE(cdp);
3138         xfs_trans_ijoin(tp, cdp, XFS_ILOCK_EXCL);
3139
3140         ASSERT(cdp->i_d.di_nlink >= 2);
3141         if (cdp->i_d.di_nlink != 2) {
3142                 error = XFS_ERROR(ENOTEMPTY);
3143                 goto error_return;
3144         }
3145         if (!xfs_dir_isempty(cdp)) {
3146                 error = XFS_ERROR(ENOTEMPTY);
3147                 goto error_return;
3148         }
3149
3150         error = xfs_dir_removename(tp, dp, name, namelen, cdp->i_ino,
3151                                         &first_block, &free_list, resblks);
3152         if (error)
3153                 goto error1;
3154
3155         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3156
3157         /*
3158          * Bump the in memory generation count on the parent
3159          * directory so that other can know that it has changed.
3160          */
3161         dp->i_gen++;
3162
3163         /*
3164          * Drop the link from cdp's "..".
3165          */
3166         error = xfs_droplink(tp, dp);
3167         if (error) {
3168                 goto error1;
3169         }
3170
3171         /*
3172          * Drop the link from dp to cdp.
3173          */
3174         error = xfs_droplink(tp, cdp);
3175         if (error) {
3176                 goto error1;
3177         }
3178
3179         /*
3180          * Drop the "." link from cdp to self.
3181          */
3182         error = xfs_droplink(tp, cdp);
3183         if (error) {
3184                 goto error1;
3185         }
3186
3187         /* Determine these before committing transaction */
3188         last_cdp_link = (cdp)->i_d.di_nlink==0;
3189
3190         /*
3191          * Take an extra ref on the child vnode so that it
3192          * does not go to xfs_inactive() from within the commit.
3193          */
3194         IHOLD(cdp);
3195
3196         /*
3197          * If this is a synchronous mount, make sure that the
3198          * rmdir transaction goes to disk before returning to
3199          * the user.
3200          */
3201         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
3202                 xfs_trans_set_sync(tp);
3203         }
3204
3205         error = xfs_bmap_finish (&tp, &free_list, &committed);
3206         if (error) {
3207                 xfs_bmap_cancel(&free_list);
3208                 xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES |
3209                                  XFS_TRANS_ABORT));
3210                 IRELE(cdp);
3211                 goto std_return;
3212         }
3213
3214         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
3215         if (error) {
3216                 IRELE(cdp);
3217                 goto std_return;
3218         }
3219
3220
3221         /*
3222          * Let interposed file systems know about removed links.
3223          */
3224         bhv_vop_link_removed(XFS_ITOV(cdp), dir_vp, last_cdp_link);
3225
3226         IRELE(cdp);
3227
3228         /* Fall through to std_return with error = 0 or the errno
3229          * from xfs_trans_commit. */
3230  std_return:
3231         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_POSTREMOVE)) {
3232                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
3233                                         dir_vp, DM_RIGHT_NULL,
3234                                         NULL, DM_RIGHT_NULL,
3235                                         name, NULL, dm_di_mode,
3236                                         error, 0);
3237         }
3238         return error;
3239
3240  error1:
3241         xfs_bmap_cancel(&free_list);
3242         cancel_flags |= XFS_TRANS_ABORT;
3243         /* FALLTHROUGH */
3244
3245  error_return:
3246         xfs_trans_cancel(tp, cancel_flags);
3247         goto std_return;
3248 }
3249
3250
3251 /*
3252  * Read dp's entries starting at uiop->uio_offset and translate them into
3253  * bufsize bytes worth of struct dirents starting at bufbase.
3254  */
3255 STATIC int
3256 xfs_readdir(
3257         bhv_desc_t      *dir_bdp,
3258         uio_t           *uiop,
3259         cred_t          *credp,
3260         int             *eofp)
3261 {
3262         xfs_inode_t     *dp;
3263         xfs_trans_t     *tp = NULL;
3264         int             error = 0;
3265         uint            lock_mode;
3266
3267         vn_trace_entry(BHV_TO_VNODE(dir_bdp), __FUNCTION__,
3268                                                (inst_t *)__return_address);
3269         dp = XFS_BHVTOI(dir_bdp);
3270
3271         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
3272                 return XFS_ERROR(EIO);
3273
3274         lock_mode = xfs_ilock_map_shared(dp);
3275         error = xfs_dir_getdents(tp, dp, uiop, eofp);
3276         xfs_iunlock_map_shared(dp, lock_mode);
3277         return error;
3278 }
3279
3280
3281 STATIC int
3282 xfs_symlink(
3283         bhv_desc_t              *dir_bdp,
3284         bhv_vname_t             *dentry,
3285         bhv_vattr_t             *vap,
3286         char                    *target_path,
3287         bhv_vnode_t             **vpp,
3288         cred_t                  *credp)
3289 {
3290         xfs_trans_t             *tp;
3291         xfs_mount_t             *mp;
3292         xfs_inode_t             *dp;
3293         xfs_inode_t             *ip;
3294         int                     error;
3295         int                     pathlen;
3296         xfs_bmap_free_t         free_list;
3297         xfs_fsblock_t           first_block;
3298         boolean_t               dp_joined_to_trans;
3299         bhv_vnode_t             *dir_vp;
3300         uint                    cancel_flags;
3301         int                     committed;
3302         xfs_fileoff_t           first_fsb;
3303         xfs_filblks_t           fs_blocks;
3304         int                     nmaps;
3305         xfs_bmbt_irec_t         mval[SYMLINK_MAPS];
3306         xfs_daddr_t             d;
3307         char                    *cur_chunk;
3308         int                     byte_cnt;
3309         int                     n;
3310         xfs_buf_t               *bp;
3311         xfs_prid_t              prid;
3312         struct xfs_dquot        *udqp, *gdqp;
3313         uint                    resblks;
3314         char                    *link_name = VNAME(dentry);
3315         int                     link_namelen;
3316
3317         *vpp = NULL;
3318         dir_vp = BHV_TO_VNODE(dir_bdp);
3319         dp = XFS_BHVTOI(dir_bdp);
3320         dp_joined_to_trans = B_FALSE;
3321         error = 0;
3322         ip = NULL;
3323         tp = NULL;
3324
3325         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
3326
3327         mp = dp->i_mount;
3328
3329         if (XFS_FORCED_SHUTDOWN(mp))
3330                 return XFS_ERROR(EIO);
3331
3332         link_namelen = VNAMELEN(dentry);
3333
3334         /*
3335          * Check component lengths of the target path name.
3336          */
3337         pathlen = strlen(target_path);
3338         if (pathlen >= MAXPATHLEN)      /* total string too long */
3339                 return XFS_ERROR(ENAMETOOLONG);
3340         if (pathlen >= MAXNAMELEN) {    /* is any component too long? */
3341                 int len, total;
3342                 char *path;
3343
3344                 for (total = 0, path = target_path; total < pathlen;) {
3345                         /*
3346                          * Skip any slashes.
3347                          */
3348                         while(*path == '/') {
3349                                 total++;
3350                                 path++;
3351                         }
3352
3353                         /*
3354                          * Count up to the next slash or end of path.
3355                          * Error out if the component is bigger than MAXNAMELEN.
3356                          */
3357                         for(len = 0; *path != '/' && total < pathlen;total++, path++) {
3358                                 if (++len >= MAXNAMELEN) {
3359                                         error = ENAMETOOLONG;
3360                                         return error;
3361                                 }
3362                         }
3363                 }
3364         }
3365
3366         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_SYMLINK)) {
3367                 error = XFS_SEND_NAMESP(mp, DM_EVENT_SYMLINK, dir_vp,
3368                                         DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
3369                                         link_name, target_path, 0, 0, 0);
3370                 if (error)
3371                         return error;
3372         }
3373
3374         /* Return through std_return after this point. */
3375
3376         udqp = gdqp = NULL;
3377         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
3378                 prid = dp->i_d.di_projid;
3379         else if (vap->va_mask & XFS_AT_PROJID)
3380                 prid = (xfs_prid_t)vap->va_projid;
3381         else
3382                 prid = (xfs_prid_t)dfltprid;
3383
3384         /*
3385          * Make sure that we have allocated dquot(s) on disk.
3386          */
3387         error = XFS_QM_DQVOPALLOC(mp, dp,
3388                         current_fsuid(credp), current_fsgid(credp), prid,
3389                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
3390         if (error)
3391                 goto std_return;
3392
3393         tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
3394         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
3395         /*
3396          * The symlink will fit into the inode data fork?
3397          * There can't be any attributes so we get the whole variable part.
3398          */
3399         if (pathlen <= XFS_LITINO(mp))
3400                 fs_blocks = 0;
3401         else
3402                 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
3403         resblks = XFS_SYMLINK_SPACE_RES(mp, link_namelen, fs_blocks);
3404         error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
3405                         XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
3406         if (error == ENOSPC && fs_blocks == 0) {
3407                 resblks = 0;
3408                 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
3409                                 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
3410         }
3411         if (error) {
3412                 cancel_flags = 0;
3413                 dp = NULL;
3414                 goto error_return;
3415         }
3416
3417         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
3418
3419         /*
3420          * Check whether the directory allows new symlinks or not.
3421          */
3422         if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
3423                 error = XFS_ERROR(EPERM);
3424                 goto error_return;
3425         }
3426
3427         /*
3428          * Reserve disk quota : blocks and inode.
3429          */
3430         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
3431         if (error)
3432                 goto error_return;
3433
3434         /*
3435          * Check for ability to enter directory entry, if no space reserved.
3436          */
3437         if (resblks == 0 &&
3438             (error = xfs_dir_canenter(tp, dp, link_name, link_namelen)))
3439                 goto error_return;
3440         /*
3441          * Initialize the bmap freelist prior to calling either
3442          * bmapi or the directory create code.
3443          */
3444         XFS_BMAP_INIT(&free_list, &first_block);
3445
3446         /*
3447          * Allocate an inode for the symlink.
3448          */
3449         error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (vap->va_mode&~S_IFMT),
3450                                1, 0, credp, prid, resblks > 0, &ip, NULL);
3451         if (error) {
3452                 if (error == ENOSPC)
3453                         goto error_return;
3454                 goto error1;
3455         }
3456         ITRACE(ip);
3457
3458         VN_HOLD(dir_vp);
3459         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
3460         dp_joined_to_trans = B_TRUE;
3461
3462         /*
3463          * Also attach the dquot(s) to it, if applicable.
3464          */
3465         XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
3466
3467         if (resblks)
3468                 resblks -= XFS_IALLOC_SPACE_RES(mp);
3469         /*
3470          * If the symlink will fit into the inode, write it inline.
3471          */
3472         if (pathlen <= XFS_IFORK_DSIZE(ip)) {
3473                 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
3474                 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
3475                 ip->i_d.di_size = pathlen;
3476
3477                 /*
3478                  * The inode was initially created in extent format.
3479                  */
3480                 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
3481                 ip->i_df.if_flags |= XFS_IFINLINE;
3482
3483                 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
3484                 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
3485
3486         } else {
3487                 first_fsb = 0;
3488                 nmaps = SYMLINK_MAPS;
3489
3490                 error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
3491                                   XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
3492                                   &first_block, resblks, mval, &nmaps,
3493                                   &free_list, NULL);
3494                 if (error) {
3495                         goto error1;
3496                 }
3497
3498                 if (resblks)
3499                         resblks -= fs_blocks;
3500                 ip->i_d.di_size = pathlen;
3501                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3502
3503                 cur_chunk = target_path;
3504                 for (n = 0; n < nmaps; n++) {
3505                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
3506                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
3507                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
3508                                                BTOBB(byte_cnt), 0);
3509                         ASSERT(bp && !XFS_BUF_GETERROR(bp));
3510                         if (pathlen < byte_cnt) {
3511                                 byte_cnt = pathlen;
3512                         }
3513                         pathlen -= byte_cnt;
3514
3515                         memcpy(XFS_BUF_PTR(bp), cur_chunk, byte_cnt);
3516                         cur_chunk += byte_cnt;
3517
3518                         xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
3519                 }
3520         }
3521
3522         /*
3523          * Create the directory entry for the symlink.
3524          */
3525         error = xfs_dir_createname(tp, dp, link_name, link_namelen, ip->i_ino,
3526                                    &first_block, &free_list, resblks);
3527         if (error)
3528                 goto error1;
3529         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3530         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
3531
3532         /*
3533          * Bump the in memory version number of the parent directory
3534          * so that other processes accessing it will recognize that
3535          * the directory has changed.
3536          */
3537         dp->i_gen++;
3538
3539         /*
3540          * If this is a synchronous mount, make sure that the
3541          * symlink transaction goes to disk before returning to
3542          * the user.
3543          */
3544         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
3545                 xfs_trans_set_sync(tp);
3546         }
3547
3548         /*
3549          * xfs_trans_commit normally decrements the vnode ref count
3550          * when it unlocks the inode. Since we want to return the
3551          * vnode to the caller, we bump the vnode ref count now.
3552          */
3553         IHOLD(ip);
3554
3555         error = xfs_bmap_finish(&tp, &free_list, &committed);
3556         if (error) {
3557                 goto error2;
3558         }
3559         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
3560         XFS_QM_DQRELE(mp, udqp);
3561         XFS_QM_DQRELE(mp, gdqp);
3562
3563         /* Fall through to std_return with error = 0 or errno from
3564          * xfs_trans_commit     */
3565 std_return:
3566         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
3567                              DM_EVENT_POSTSYMLINK)) {
3568                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTSYMLINK,
3569                                         dir_vp, DM_RIGHT_NULL,
3570                                         error ? NULL : XFS_ITOV(ip),
3571                                         DM_RIGHT_NULL, link_name, target_path,
3572                                         0, error, 0);
3573         }
3574
3575         if (!error) {
3576                 bhv_vnode_t *vp;
3577
3578                 ASSERT(ip);
3579                 vp = XFS_ITOV(ip);
3580                 *vpp = vp;
3581         }
3582         return error;
3583
3584  error2:
3585         IRELE(ip);
3586  error1:
3587         xfs_bmap_cancel(&free_list);
3588         cancel_flags |= XFS_TRANS_ABORT;
3589  error_return:
3590         xfs_trans_cancel(tp, cancel_flags);
3591         XFS_QM_DQRELE(mp, udqp);
3592         XFS_QM_DQRELE(mp, gdqp);
3593
3594         if (!dp_joined_to_trans && (dp != NULL)) {
3595                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
3596         }
3597
3598         goto std_return;
3599 }
3600
3601
3602 /*
3603  * xfs_fid2
3604  *
3605  * A fid routine that takes a pointer to a previously allocated
3606  * fid structure (like xfs_fast_fid) but uses a 64 bit inode number.
3607  */
3608 STATIC int
3609 xfs_fid2(
3610         bhv_desc_t      *bdp,
3611         fid_t           *fidp)
3612 {
3613         xfs_inode_t     *ip;
3614         xfs_fid2_t      *xfid;
3615
3616         vn_trace_entry(BHV_TO_VNODE(bdp), __FUNCTION__,
3617                                        (inst_t *)__return_address);
3618         ASSERT(sizeof(fid_t) >= sizeof(xfs_fid2_t));
3619
3620         xfid = (xfs_fid2_t *)fidp;
3621         ip = XFS_BHVTOI(bdp);
3622         xfid->fid_len = sizeof(xfs_fid2_t) - sizeof(xfid->fid_len);
3623         xfid->fid_pad = 0;
3624         /*
3625          * use memcpy because the inode is a long long and there's no
3626          * assurance that xfid->fid_ino is properly aligned.
3627          */
3628         memcpy(&xfid->fid_ino, &ip->i_ino, sizeof(xfid->fid_ino));
3629         xfid->fid_gen = ip->i_d.di_gen;
3630
3631         return 0;
3632 }
3633
3634
3635 /*
3636  * xfs_rwlock
3637  */
3638 int
3639 xfs_rwlock(
3640         bhv_desc_t      *bdp,
3641         bhv_vrwlock_t   locktype)
3642 {
3643         xfs_inode_t     *ip;
3644         bhv_vnode_t     *vp;
3645
3646         vp = BHV_TO_VNODE(bdp);
3647         if (VN_ISDIR(vp))
3648                 return 1;
3649         ip = XFS_BHVTOI(bdp);
3650         if (locktype == VRWLOCK_WRITE) {
3651                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
3652         } else if (locktype == VRWLOCK_TRY_READ) {
3653                 return xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED);
3654         } else if (locktype == VRWLOCK_TRY_WRITE) {
3655                 return xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL);
3656         } else {
3657                 ASSERT((locktype == VRWLOCK_READ) ||
3658                        (locktype == VRWLOCK_WRITE_DIRECT));
3659                 xfs_ilock(ip, XFS_IOLOCK_SHARED);
3660         }
3661
3662         return 1;
3663 }
3664
3665
3666 /*
3667  * xfs_rwunlock
3668  */
3669 void
3670 xfs_rwunlock(
3671         bhv_desc_t      *bdp,
3672         bhv_vrwlock_t   locktype)
3673 {
3674         xfs_inode_t     *ip;
3675         bhv_vnode_t     *vp;
3676
3677         vp = BHV_TO_VNODE(bdp);
3678         if (VN_ISDIR(vp))
3679                 return;
3680         ip = XFS_BHVTOI(bdp);
3681         if (locktype == VRWLOCK_WRITE) {
3682                 /*
3683                  * In the write case, we may have added a new entry to
3684                  * the reference cache.  This might store a pointer to
3685                  * an inode to be released in this inode.  If it is there,
3686                  * clear the pointer and release the inode after unlocking
3687                  * this one.
3688                  */
3689                 xfs_refcache_iunlock(ip, XFS_IOLOCK_EXCL);
3690         } else {
3691                 ASSERT((locktype == VRWLOCK_READ) ||
3692                        (locktype == VRWLOCK_WRITE_DIRECT));
3693                 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
3694         }
3695         return;
3696 }
3697
3698 STATIC int
3699 xfs_inode_flush(
3700         bhv_desc_t      *bdp,
3701         int             flags)
3702 {
3703         xfs_inode_t     *ip;
3704         xfs_mount_t     *mp;
3705         xfs_inode_log_item_t *iip;
3706         int             error = 0;
3707
3708         ip = XFS_BHVTOI(bdp);
3709         mp = ip->i_mount;
3710         iip = ip->i_itemp;
3711
3712         if (XFS_FORCED_SHUTDOWN(mp))
3713                 return XFS_ERROR(EIO);
3714
3715         /*
3716          * Bypass inodes which have already been cleaned by
3717          * the inode flush clustering code inside xfs_iflush
3718          */
3719         if ((ip->i_update_core == 0) &&
3720             ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL)))
3721                 return 0;
3722
3723         if (flags & FLUSH_LOG) {
3724                 if (iip && iip->ili_last_lsn) {
3725                         xlog_t          *log = mp->m_log;
3726                         xfs_lsn_t       sync_lsn;
3727                         int             s, log_flags = XFS_LOG_FORCE;
3728
3729                         s = GRANT_LOCK(log);
3730                         sync_lsn = log->l_last_sync_lsn;
3731                         GRANT_UNLOCK(log, s);
3732
3733                         if ((XFS_LSN_CMP(iip->ili_last_lsn, sync_lsn) <= 0))
3734                                 return 0;
3735
3736                         if (flags & FLUSH_SYNC)
3737                                 log_flags |= XFS_LOG_SYNC;
3738                         return xfs_log_force(mp, iip->ili_last_lsn, log_flags);
3739                 }
3740         }
3741
3742         /*
3743          * We make this non-blocking if the inode is contended,
3744          * return EAGAIN to indicate to the caller that they
3745          * did not succeed. This prevents the flush path from
3746          * blocking on inodes inside another operation right
3747          * now, they get caught later by xfs_sync.
3748          */
3749         if (flags & FLUSH_INODE) {
3750                 int     flush_flags;
3751
3752                 if (xfs_ipincount(ip))
3753                         return EAGAIN;
3754
3755                 if (flags & FLUSH_SYNC) {
3756                         xfs_ilock(ip, XFS_ILOCK_SHARED);
3757                         xfs_iflock(ip);
3758                 } else if (xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
3759                         if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip)) {
3760                                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
3761                                 return EAGAIN;
3762                         }
3763                 } else {
3764                         return EAGAIN;
3765                 }
3766
3767                 if (flags & FLUSH_SYNC)
3768                         flush_flags = XFS_IFLUSH_SYNC;
3769                 else
3770                         flush_flags = XFS_IFLUSH_ASYNC;
3771
3772                 error = xfs_iflush(ip, flush_flags);
3773                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
3774         }
3775
3776         return error;
3777 }
3778
3779 int
3780 xfs_set_dmattrs (
3781         bhv_desc_t      *bdp,
3782         u_int           evmask,
3783         u_int16_t       state,
3784         cred_t          *credp)
3785 {
3786         xfs_inode_t     *ip;
3787         xfs_trans_t     *tp;
3788         xfs_mount_t     *mp;
3789         int             error;
3790
3791         if (!capable(CAP_SYS_ADMIN))
3792                 return XFS_ERROR(EPERM);
3793
3794         ip = XFS_BHVTOI(bdp);
3795         mp = ip->i_mount;
3796
3797         if (XFS_FORCED_SHUTDOWN(mp))
3798                 return XFS_ERROR(EIO);
3799
3800         tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
3801         error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
3802         if (error) {
3803                 xfs_trans_cancel(tp, 0);
3804                 return error;
3805         }
3806         xfs_ilock(ip, XFS_ILOCK_EXCL);
3807         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3808
3809         ip->i_iocore.io_dmevmask = ip->i_d.di_dmevmask = evmask;
3810         ip->i_iocore.io_dmstate  = ip->i_d.di_dmstate  = state;
3811
3812         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3813         IHOLD(ip);
3814         error = xfs_trans_commit(tp, 0);
3815
3816         return error;
3817 }
3818
3819 STATIC int
3820 xfs_reclaim(
3821         bhv_desc_t      *bdp)
3822 {
3823         xfs_inode_t     *ip;
3824         bhv_vnode_t     *vp;
3825
3826         vp = BHV_TO_VNODE(bdp);
3827         ip = XFS_BHVTOI(bdp);
3828
3829         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
3830
3831         ASSERT(!VN_MAPPED(vp));
3832
3833         /* bad inode, get out here ASAP */
3834         if (VN_BAD(vp)) {
3835                 xfs_ireclaim(ip);
3836                 return 0;
3837         }
3838
3839         vn_iowait(vp);
3840
3841         ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
3842
3843         /*
3844          * Make sure the atime in the XFS inode is correct before freeing the
3845          * Linux inode.
3846          */
3847         xfs_synchronize_atime(ip);
3848
3849         /*
3850          * If we have nothing to flush with this inode then complete the
3851          * teardown now, otherwise break the link between the xfs inode and the
3852          * linux inode and clean up the xfs inode later. This avoids flushing
3853          * the inode to disk during the delete operation itself.
3854          *
3855          * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
3856          * first to ensure that xfs_iunpin() will never see an xfs inode
3857          * that has a linux inode being reclaimed. Synchronisation is provided
3858          * by the i_flags_lock.
3859          */
3860         if (!ip->i_update_core && (ip->i_itemp == NULL)) {
3861                 xfs_ilock(ip, XFS_ILOCK_EXCL);
3862                 xfs_iflock(ip);
3863                 return xfs_finish_reclaim(ip, 1, XFS_IFLUSH_DELWRI_ELSE_SYNC);
3864         } else {
3865                 xfs_mount_t     *mp = ip->i_mount;
3866
3867                 /* Protect sync and unpin from us */
3868                 XFS_MOUNT_ILOCK(mp);
3869                 spin_lock(&ip->i_flags_lock);
3870                 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
3871                 vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
3872                 spin_unlock(&ip->i_flags_lock);
3873                 list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
3874                 XFS_MOUNT_IUNLOCK(mp);
3875         }
3876         return 0;
3877 }
3878
3879 int
3880 xfs_finish_reclaim(
3881         xfs_inode_t     *ip,
3882         int             locked,
3883         int             sync_mode)
3884 {
3885         xfs_ihash_t     *ih = ip->i_hash;
3886         bhv_vnode_t     *vp = XFS_ITOV_NULL(ip);
3887         int             error;
3888
3889         if (vp && VN_BAD(vp))
3890                 goto reclaim;
3891
3892         /* The hash lock here protects a thread in xfs_iget_core from
3893          * racing with us on linking the inode back with a vnode.
3894          * Once we have the XFS_IRECLAIM flag set it will not touch
3895          * us.
3896          */
3897         write_lock(&ih->ih_lock);
3898         spin_lock(&ip->i_flags_lock);
3899         if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
3900             (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) && vp == NULL)) {
3901                 spin_unlock(&ip->i_flags_lock);
3902                 write_unlock(&ih->ih_lock);
3903                 if (locked) {
3904                         xfs_ifunlock(ip);
3905                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
3906                 }
3907                 return 1;
3908         }
3909         __xfs_iflags_set(ip, XFS_IRECLAIM);
3910         spin_unlock(&ip->i_flags_lock);
3911         write_unlock(&ih->ih_lock);
3912
3913         /*
3914          * If the inode is still dirty, then flush it out.  If the inode
3915          * is not in the AIL, then it will be OK to flush it delwri as
3916          * long as xfs_iflush() does not keep any references to the inode.
3917          * We leave that decision up to xfs_iflush() since it has the
3918          * knowledge of whether it's OK to simply do a delwri flush of
3919          * the inode or whether we need to wait until the inode is
3920          * pulled from the AIL.
3921          * We get the flush lock regardless, though, just to make sure
3922          * we don't free it while it is being flushed.
3923          */
3924         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
3925                 if (!locked) {
3926                         xfs_ilock(ip, XFS_ILOCK_EXCL);
3927                         xfs_iflock(ip);
3928                 }
3929
3930                 if (ip->i_update_core ||
3931                     ((ip->i_itemp != NULL) &&
3932                      (ip->i_itemp->ili_format.ilf_fields != 0))) {
3933                         error = xfs_iflush(ip, sync_mode);
3934                         /*
3935                          * If we hit an error, typically because of filesystem
3936                          * shutdown, we don't need to let vn_reclaim to know
3937                          * because we're gonna reclaim the inode anyway.
3938                          */
3939                         if (error) {
3940                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3941                                 goto reclaim;
3942                         }
3943                         xfs_iflock(ip); /* synchronize with xfs_iflush_done */
3944                 }
3945
3946                 ASSERT(ip->i_update_core == 0);
3947                 ASSERT(ip->i_itemp == NULL ||
3948                        ip->i_itemp->ili_format.ilf_fields == 0);
3949                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3950         } else if (locked) {
3951                 /*
3952                  * We are not interested in doing an iflush if we're
3953                  * in the process of shutting down the filesystem forcibly.
3954                  * So, just reclaim the inode.
3955                  */
3956                 xfs_ifunlock(ip);
3957                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3958         }
3959
3960  reclaim:
3961         xfs_ireclaim(ip);
3962         return 0;
3963 }
3964
3965 int
3966 xfs_finish_reclaim_all(xfs_mount_t *mp, int noblock)
3967 {
3968         int             purged;
3969         xfs_inode_t     *ip, *n;
3970         int             done = 0;
3971
3972         while (!done) {
3973                 purged = 0;
3974                 XFS_MOUNT_ILOCK(mp);
3975                 list_for_each_entry_safe(ip, n, &mp->m_del_inodes, i_reclaim) {
3976                         if (noblock) {
3977                                 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0)
3978                                         continue;
3979                                 if (xfs_ipincount(ip) ||
3980                                     !xfs_iflock_nowait(ip)) {
3981                                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
3982                                         continue;
3983                                 }
3984                         }
3985                         XFS_MOUNT_IUNLOCK(mp);
3986                         if (xfs_finish_reclaim(ip, noblock,
3987                                         XFS_IFLUSH_DELWRI_ELSE_ASYNC))
3988                                 delay(1);
3989                         purged = 1;
3990                         break;
3991                 }
3992
3993                 done = !purged;
3994         }
3995
3996         XFS_MOUNT_IUNLOCK(mp);
3997         return 0;
3998 }
3999
4000 /*
4001  * xfs_alloc_file_space()
4002  *      This routine allocates disk space for the given file.
4003  *
4004  *      If alloc_type == 0, this request is for an ALLOCSP type
4005  *      request which will change the file size.  In this case, no
4006  *      DMAPI event will be generated by the call.  A TRUNCATE event
4007  *      will be generated later by xfs_setattr.
4008  *
4009  *      If alloc_type != 0, this request is for a RESVSP type
4010  *      request, and a DMAPI DM_EVENT_WRITE will be generated if the
4011  *      lower block boundary byte address is less than the file's
4012  *      length.
4013  *
4014  * RETURNS:
4015  *       0 on success
4016  *      errno on error
4017  *
4018  */
4019 STATIC int
4020 xfs_alloc_file_space(
4021         xfs_inode_t             *ip,
4022         xfs_off_t               offset,
4023         xfs_off_t               len,
4024         int                     alloc_type,
4025         int                     attr_flags)
4026 {
4027         xfs_mount_t             *mp = ip->i_mount;
4028         xfs_off_t               count;
4029         xfs_filblks_t           allocated_fsb;
4030         xfs_filblks_t           allocatesize_fsb;
4031         xfs_extlen_t            extsz, temp;
4032         xfs_fileoff_t           startoffset_fsb;
4033         xfs_fsblock_t           firstfsb;
4034         int                     nimaps;
4035         int                     bmapi_flag;
4036         int                     quota_flag;
4037         int                     rt;
4038         xfs_trans_t             *tp;
4039         xfs_bmbt_irec_t         imaps[1], *imapp;
4040         xfs_bmap_free_t         free_list;
4041         uint                    qblocks, resblks, resrtextents;
4042         int                     committed;
4043         int                     error;
4044
4045         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
4046
4047         if (XFS_FORCED_SHUTDOWN(mp))
4048                 return XFS_ERROR(EIO);
4049
4050         rt = XFS_IS_REALTIME_INODE(ip);
4051         if (unlikely(rt)) {
4052                 if (!(extsz = ip->i_d.di_extsize))
4053                         extsz = mp->m_sb.sb_rextsize;
4054         } else {
4055                 extsz = ip->i_d.di_extsize;
4056         }
4057
4058         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
4059                 return error;
4060
4061         if (len <= 0)
4062                 return XFS_ERROR(EINVAL);
4063
4064         count = len;
4065         error = 0;
4066         imapp = &imaps[0];
4067         nimaps = 1;
4068         bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
4069         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
4070         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
4071
4072         /*      Generate a DMAPI event if needed.       */
4073         if (alloc_type != 0 && offset < ip->i_size &&
4074                         (attr_flags&ATTR_DMI) == 0  &&
4075                         DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_WRITE)) {
4076                 xfs_off_t           end_dmi_offset;
4077
4078                 end_dmi_offset = offset+len;
4079                 if (end_dmi_offset > ip->i_size)
4080                         end_dmi_offset = ip->i_size;
4081                 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, XFS_ITOV(ip),
4082                         offset, end_dmi_offset - offset,
4083                         0, NULL);
4084                 if (error)
4085                         return error;
4086         }
4087
4088         /*
4089          * Allocate file space until done or until there is an error
4090          */
4091 retry:
4092         while (allocatesize_fsb && !error) {
4093                 xfs_fileoff_t   s, e;
4094
4095                 /*
4096                  * Determine space reservations for data/realtime.
4097                  */
4098                 if (unlikely(extsz)) {
4099                         s = startoffset_fsb;
4100                         do_div(s, extsz);
4101                         s *= extsz;
4102                         e = startoffset_fsb + allocatesize_fsb;
4103                         if ((temp = do_mod(startoffset_fsb, extsz)))
4104                                 e += temp;
4105                         if ((temp = do_mod(e, extsz)))
4106                                 e += extsz - temp;
4107                 } else {
4108                         s = 0;
4109                         e = allocatesize_fsb;
4110                 }
4111
4112                 if (unlikely(rt)) {
4113                         resrtextents = qblocks = (uint)(e - s);
4114                         resrtextents /= mp->m_sb.sb_rextsize;
4115                         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
4116                         quota_flag = XFS_QMOPT_RES_RTBLKS;
4117                 } else {
4118                         resrtextents = 0;
4119                         resblks = qblocks = \
4120                                 XFS_DIOSTRAT_SPACE_RES(mp, (uint)(e - s));
4121                         quota_flag = XFS_QMOPT_RES_REGBLKS;
4122                 }
4123
4124                 /*
4125                  * Allocate and setup the transaction.
4126                  */
4127                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
4128                 error = xfs_trans_reserve(tp, resblks,
4129                                           XFS_WRITE_LOG_RES(mp), resrtextents,
4130                                           XFS_TRANS_PERM_LOG_RES,
4131                                           XFS_WRITE_LOG_COUNT);
4132                 /*
4133                  * Check for running out of space
4134                  */
4135                 if (error) {
4136                         /*
4137                          * Free the transaction structure.
4138                          */
4139                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
4140                         xfs_trans_cancel(tp, 0);
4141                         break;
4142                 }
4143                 xfs_ilock(ip, XFS_ILOCK_EXCL);
4144                 error = XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip,
4145                                                       qblocks, 0, quota_flag);
4146                 if (error)
4147                         goto error1;
4148
4149                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4150                 xfs_trans_ihold(tp, ip);
4151
4152                 /*
4153                  * Issue the xfs_bmapi() call to allocate the blocks
4154                  */
4155                 XFS_BMAP_INIT(&free_list, &firstfsb);
4156                 error = XFS_BMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
4157                                   allocatesize_fsb, bmapi_flag,
4158                                   &firstfsb, 0, imapp, &nimaps,
4159                                   &free_list, NULL);
4160                 if (error) {
4161                         goto error0;
4162                 }
4163
4164                 /*
4165                  * Complete the transaction
4166                  */
4167                 error = xfs_bmap_finish(&tp, &free_list, &committed);
4168                 if (error) {
4169                         goto error0;
4170                 }
4171
4172                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
4173                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4174                 if (error) {
4175                         break;
4176                 }
4177
4178                 allocated_fsb = imapp->br_blockcount;
4179
4180                 if (nimaps == 0) {
4181                         error = XFS_ERROR(ENOSPC);
4182                         break;
4183                 }
4184
4185                 startoffset_fsb += allocated_fsb;
4186                 allocatesize_fsb -= allocated_fsb;
4187         }
4188 dmapi_enospc_check:
4189         if (error == ENOSPC && (attr_flags&ATTR_DMI) == 0 &&
4190             DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_NOSPACE)) {
4191
4192                 error = XFS_SEND_NAMESP(mp, DM_EVENT_NOSPACE,
4193                                 XFS_ITOV(ip), DM_RIGHT_NULL,
4194                                 XFS_ITOV(ip), DM_RIGHT_NULL,
4195                                 NULL, NULL, 0, 0, 0); /* Delay flag intentionally unused */
4196                 if (error == 0)
4197                         goto retry;     /* Maybe DMAPI app. has made space */
4198                 /* else fall through with error from XFS_SEND_DATA */
4199         }
4200
4201         return error;
4202
4203 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
4204         xfs_bmap_cancel(&free_list);
4205         XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp, tp, ip, qblocks, 0, quota_flag);
4206
4207 error1: /* Just cancel transaction */
4208         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
4209         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4210         goto dmapi_enospc_check;
4211 }
4212
4213 /*
4214  * Zero file bytes between startoff and endoff inclusive.
4215  * The iolock is held exclusive and no blocks are buffered.
4216  */
4217 STATIC int
4218 xfs_zero_remaining_bytes(
4219         xfs_inode_t             *ip,
4220         xfs_off_t               startoff,
4221         xfs_off_t               endoff)
4222 {
4223         xfs_bmbt_irec_t         imap;
4224         xfs_fileoff_t           offset_fsb;
4225         xfs_off_t               lastoffset;
4226         xfs_off_t               offset;
4227         xfs_buf_t               *bp;
4228         xfs_mount_t             *mp = ip->i_mount;
4229         int                     nimap;
4230         int                     error = 0;
4231
4232         bp = xfs_buf_get_noaddr(mp->m_sb.sb_blocksize,
4233                                 ip->i_d.di_flags & XFS_DIFLAG_REALTIME ?
4234                                 mp->m_rtdev_targp : mp->m_ddev_targp);
4235
4236         for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
4237                 offset_fsb = XFS_B_TO_FSBT(mp, offset);
4238                 nimap = 1;
4239                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, offset_fsb, 1, 0,
4240                         NULL, 0, &imap, &nimap, NULL, NULL);
4241                 if (error || nimap < 1)
4242                         break;
4243                 ASSERT(imap.br_blockcount >= 1);
4244                 ASSERT(imap.br_startoff == offset_fsb);
4245                 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
4246                 if (lastoffset > endoff)
4247                         lastoffset = endoff;
4248                 if (imap.br_startblock == HOLESTARTBLOCK)
4249                         continue;
4250                 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4251                 if (imap.br_state == XFS_EXT_UNWRITTEN)
4252                         continue;
4253                 XFS_BUF_UNDONE(bp);
4254                 XFS_BUF_UNWRITE(bp);
4255                 XFS_BUF_READ(bp);
4256                 XFS_BUF_SET_ADDR(bp, XFS_FSB_TO_DB(ip, imap.br_startblock));
4257                 xfsbdstrat(mp, bp);
4258                 if ((error = xfs_iowait(bp))) {
4259                         xfs_ioerror_alert("xfs_zero_remaining_bytes(read)",
4260                                           mp, bp, XFS_BUF_ADDR(bp));
4261                         break;
4262                 }
4263                 memset(XFS_BUF_PTR(bp) +
4264                         (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
4265                       0, lastoffset - offset + 1);
4266                 XFS_BUF_UNDONE(bp);
4267                 XFS_BUF_UNREAD(bp);
4268                 XFS_BUF_WRITE(bp);
4269                 xfsbdstrat(mp, bp);
4270                 if ((error = xfs_iowait(bp))) {
4271                         xfs_ioerror_alert("xfs_zero_remaining_bytes(write)",
4272                                           mp, bp, XFS_BUF_ADDR(bp));
4273                         break;
4274                 }
4275         }
4276         xfs_buf_free(bp);
4277         return error;
4278 }
4279
4280 /*
4281  * xfs_free_file_space()
4282  *      This routine frees disk space for the given file.
4283  *
4284  *      This routine is only called by xfs_change_file_space
4285  *      for an UNRESVSP type call.
4286  *
4287  * RETURNS:
4288  *       0 on success
4289  *      errno on error
4290  *
4291  */
4292 STATIC int
4293 xfs_free_file_space(
4294         xfs_inode_t             *ip,
4295         xfs_off_t               offset,
4296         xfs_off_t               len,
4297         int                     attr_flags)
4298 {
4299         bhv_vnode_t             *vp;
4300         int                     committed;
4301         int                     done;
4302         xfs_off_t               end_dmi_offset;
4303         xfs_fileoff_t           endoffset_fsb;
4304         int                     error;
4305         xfs_fsblock_t           firstfsb;
4306         xfs_bmap_free_t         free_list;
4307         xfs_bmbt_irec_t         imap;
4308         xfs_off_t               ioffset;
4309         xfs_extlen_t            mod=0;
4310         xfs_mount_t             *mp;
4311         int                     nimap;
4312         uint                    resblks;
4313         uint                    rounding;
4314         int                     rt;
4315         xfs_fileoff_t           startoffset_fsb;
4316         xfs_trans_t             *tp;
4317         int                     need_iolock = 1;
4318
4319         vp = XFS_ITOV(ip);
4320         mp = ip->i_mount;
4321
4322         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
4323
4324         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
4325                 return error;
4326
4327         error = 0;
4328         if (len <= 0)   /* if nothing being freed */
4329                 return error;
4330         rt = (ip->i_d.di_flags & XFS_DIFLAG_REALTIME);
4331         startoffset_fsb = XFS_B_TO_FSB(mp, offset);
4332         end_dmi_offset = offset + len;
4333         endoffset_fsb = XFS_B_TO_FSBT(mp, end_dmi_offset);
4334
4335         if (offset < ip->i_size &&
4336             (attr_flags & ATTR_DMI) == 0 &&
4337             DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_WRITE)) {
4338                 if (end_dmi_offset > ip->i_size)
4339                         end_dmi_offset = ip->i_size;
4340                 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, vp,
4341                                 offset, end_dmi_offset - offset,
4342                                 AT_DELAY_FLAG(attr_flags), NULL);
4343                 if (error)
4344                         return error;
4345         }
4346
4347         if (attr_flags & ATTR_NOLOCK)
4348                 need_iolock = 0;
4349         if (need_iolock) {
4350                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
4351                 vn_iowait(vp);  /* wait for the completion of any pending DIOs */
4352         }
4353
4354         rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, NBPP);
4355         ioffset = offset & ~(rounding - 1);
4356
4357         if (VN_CACHED(vp) != 0) {
4358                 xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
4359                                 ctooff(offtoct(ioffset)), -1);
4360                 error = bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
4361                                 -1, FI_REMAPF_LOCKED);
4362                 if (error)
4363                         goto out_unlock_iolock;
4364         }
4365
4366         /*
4367          * Need to zero the stuff we're not freeing, on disk.
4368          * If its a realtime file & can't use unwritten extents then we
4369          * actually need to zero the extent edges.  Otherwise xfs_bunmapi
4370          * will take care of it for us.
4371          */
4372         if (rt && !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
4373                 nimap = 1;
4374                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, startoffset_fsb,
4375                         1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
4376                 if (error)
4377                         goto out_unlock_iolock;
4378                 ASSERT(nimap == 0 || nimap == 1);
4379                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
4380                         xfs_daddr_t     block;
4381
4382                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4383                         block = imap.br_startblock;
4384                         mod = do_div(block, mp->m_sb.sb_rextsize);
4385                         if (mod)
4386                                 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
4387                 }
4388                 nimap = 1;
4389                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, endoffset_fsb - 1,
4390                         1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
4391                 if (error)
4392                         goto out_unlock_iolock;
4393                 ASSERT(nimap == 0 || nimap == 1);
4394                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
4395                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4396                         mod++;
4397                         if (mod && (mod != mp->m_sb.sb_rextsize))
4398                                 endoffset_fsb -= mod;
4399                 }
4400         }
4401         if ((done = (endoffset_fsb <= startoffset_fsb)))
4402                 /*
4403                  * One contiguous piece to clear
4404                  */
4405                 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
4406         else {
4407                 /*
4408                  * Some full blocks, possibly two pieces to clear
4409                  */
4410                 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
4411                         error = xfs_zero_remaining_bytes(ip, offset,
4412                                 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
4413                 if (!error &&
4414                     XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
4415                         error = xfs_zero_remaining_bytes(ip,
4416                                 XFS_FSB_TO_B(mp, endoffset_fsb),
4417                                 offset + len - 1);
4418         }
4419
4420         /*
4421          * free file space until done or until there is an error
4422          */
4423         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
4424         while (!error && !done) {
4425
4426                 /*
4427                  * allocate and setup the transaction
4428                  */
4429                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
4430                 error = xfs_trans_reserve(tp,
4431                                           resblks,
4432                                           XFS_WRITE_LOG_RES(mp),
4433                                           0,
4434                                           XFS_TRANS_PERM_LOG_RES,
4435                                           XFS_WRITE_LOG_COUNT);
4436
4437                 /*
4438                  * check for running out of space
4439                  */
4440                 if (error) {
4441                         /*
4442                          * Free the transaction structure.
4443                          */
4444                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
4445                         xfs_trans_cancel(tp, 0);
4446                         break;
4447                 }
4448                 xfs_ilock(ip, XFS_ILOCK_EXCL);
4449                 error = XFS_TRANS_RESERVE_QUOTA(mp, tp,
4450                                 ip->i_udquot, ip->i_gdquot, resblks, 0,
4451                                 XFS_QMOPT_RES_REGBLKS);
4452                 if (error)
4453                         goto error1;
4454
4455                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4456                 xfs_trans_ihold(tp, ip);
4457
4458                 /*
4459                  * issue the bunmapi() call to free the blocks
4460                  */
4461                 XFS_BMAP_INIT(&free_list, &firstfsb);
4462                 error = XFS_BUNMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
4463                                   endoffset_fsb - startoffset_fsb,
4464                                   0, 2, &firstfsb, &free_list, NULL, &done);
4465                 if (error) {
4466                         goto error0;
4467                 }
4468
4469                 /*
4470                  * complete the transaction
4471                  */
4472                 error = xfs_bmap_finish(&tp, &free_list, &committed);
4473                 if (error) {
4474                         goto error0;
4475                 }
4476
4477                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
4478                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4479         }
4480
4481  out_unlock_iolock:
4482         if (need_iolock)
4483                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
4484         return error;
4485
4486  error0:
4487         xfs_bmap_cancel(&free_list);
4488  error1:
4489         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
4490         xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
4491                     XFS_ILOCK_EXCL);
4492         return error;
4493 }
4494
4495 /*
4496  * xfs_change_file_space()
4497  *      This routine allocates or frees disk space for the given file.
4498  *      The user specified parameters are checked for alignment and size
4499  *      limitations.
4500  *
4501  * RETURNS:
4502  *       0 on success
4503  *      errno on error
4504  *
4505  */
4506 int
4507 xfs_change_file_space(
4508         bhv_desc_t      *bdp,
4509         int             cmd,
4510         xfs_flock64_t   *bf,
4511         xfs_off_t       offset,
4512         cred_t          *credp,
4513         int             attr_flags)
4514 {
4515         int             clrprealloc;
4516         int             error;
4517         xfs_fsize_t     fsize;
4518         xfs_inode_t     *ip;
4519         xfs_mount_t     *mp;
4520         int             setprealloc;
4521         xfs_off_t       startoffset;
4522         xfs_off_t       llen;
4523         xfs_trans_t     *tp;
4524         bhv_vattr_t     va;
4525         bhv_vnode_t     *vp;
4526
4527         vp = BHV_TO_VNODE(bdp);
4528         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
4529
4530         ip = XFS_BHVTOI(bdp);
4531         mp = ip->i_mount;
4532
4533         /*
4534          * must be a regular file and have write permission
4535          */
4536         if (!VN_ISREG(vp))
4537                 return XFS_ERROR(EINVAL);
4538
4539         xfs_ilock(ip, XFS_ILOCK_SHARED);
4540
4541         if ((error = xfs_iaccess(ip, S_IWUSR, credp))) {
4542                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
4543                 return error;
4544         }
4545
4546         xfs_iunlock(ip, XFS_ILOCK_SHARED);
4547
4548         switch (bf->l_whence) {
4549         case 0: /*SEEK_SET*/
4550                 break;
4551         case 1: /*SEEK_CUR*/
4552                 bf->l_start += offset;
4553                 break;
4554         case 2: /*SEEK_END*/
4555                 bf->l_start += ip->i_size;
4556                 break;
4557         default:
4558                 return XFS_ERROR(EINVAL);
4559         }
4560
4561         llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
4562
4563         if (   (bf->l_start < 0)
4564             || (bf->l_start > XFS_MAXIOFFSET(mp))
4565             || (bf->l_start + llen < 0)
4566             || (bf->l_start + llen > XFS_MAXIOFFSET(mp)))
4567                 return XFS_ERROR(EINVAL);
4568
4569         bf->l_whence = 0;
4570
4571         startoffset = bf->l_start;
4572         fsize = ip->i_size;
4573
4574         /*
4575          * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
4576          * file space.
4577          * These calls do NOT zero the data space allocated to the file,
4578          * nor do they change the file size.
4579          *
4580          * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
4581          * space.
4582          * These calls cause the new file data to be zeroed and the file
4583          * size to be changed.
4584          */
4585         setprealloc = clrprealloc = 0;
4586
4587         switch (cmd) {
4588         case XFS_IOC_RESVSP:
4589         case XFS_IOC_RESVSP64:
4590                 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
4591                                                                 1, attr_flags);
4592                 if (error)
4593                         return error;
4594                 setprealloc = 1;
4595                 break;
4596
4597         case XFS_IOC_UNRESVSP:
4598         case XFS_IOC_UNRESVSP64:
4599                 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
4600                                                                 attr_flags)))
4601                         return error;
4602                 break;
4603
4604         case XFS_IOC_ALLOCSP:
4605         case XFS_IOC_ALLOCSP64:
4606         case XFS_IOC_FREESP:
4607         case XFS_IOC_FREESP64:
4608                 if (startoffset > fsize) {
4609                         error = xfs_alloc_file_space(ip, fsize,
4610                                         startoffset - fsize, 0, attr_flags);
4611                         if (error)
4612                                 break;
4613                 }
4614
4615                 va.va_mask = XFS_AT_SIZE;
4616                 va.va_size = startoffset;
4617
4618                 error = xfs_setattr(bdp, &va, attr_flags, credp);
4619
4620                 if (error)
4621                         return error;
4622
4623                 clrprealloc = 1;
4624                 break;
4625
4626         default:
4627                 ASSERT(0);
4628                 return XFS_ERROR(EINVAL);
4629         }
4630
4631         /*
4632          * update the inode timestamp, mode, and prealloc flag bits
4633          */
4634         tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
4635
4636         if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
4637                                       0, 0, 0))) {
4638                 /* ASSERT(0); */
4639                 xfs_trans_cancel(tp, 0);
4640                 return error;
4641         }
4642
4643         xfs_ilock(ip, XFS_ILOCK_EXCL);
4644
4645         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4646         xfs_trans_ihold(tp, ip);
4647
4648         if ((attr_flags & ATTR_DMI) == 0) {
4649                 ip->i_d.di_mode &= ~S_ISUID;
4650
4651                 /*
4652                  * Note that we don't have to worry about mandatory
4653                  * file locking being disabled here because we only
4654                  * clear the S_ISGID bit if the Group execute bit is
4655                  * on, but if it was on then mandatory locking wouldn't
4656                  * have been enabled.
4657                  */
4658                 if (ip->i_d.di_mode & S_IXGRP)
4659                         ip->i_d.di_mode &= ~S_ISGID;
4660
4661                 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
4662         }
4663         if (setprealloc)
4664                 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
4665         else if (clrprealloc)
4666                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
4667
4668         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4669         xfs_trans_set_sync(tp);
4670
4671         error = xfs_trans_commit(tp, 0);
4672
4673         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4674
4675         return error;
4676 }
4677
4678 bhv_vnodeops_t xfs_vnodeops = {
4679         BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
4680         .vop_open               = xfs_open,
4681         .vop_close              = xfs_close,
4682         .vop_read               = xfs_read,
4683 #ifdef HAVE_SPLICE
4684         .vop_splice_read        = xfs_splice_read,
4685         .vop_splice_write       = xfs_splice_write,
4686 #endif
4687         .vop_write              = xfs_write,
4688         .vop_ioctl              = xfs_ioctl,
4689         .vop_getattr            = xfs_getattr,
4690         .vop_setattr            = xfs_setattr,
4691         .vop_access             = xfs_access,
4692         .vop_lookup             = xfs_lookup,
4693         .vop_create             = xfs_create,
4694         .vop_remove             = xfs_remove,
4695         .vop_link               = xfs_link,
4696         .vop_rename             = xfs_rename,
4697         .vop_mkdir              = xfs_mkdir,
4698         .vop_rmdir              = xfs_rmdir,
4699         .vop_readdir            = xfs_readdir,
4700         .vop_symlink            = xfs_symlink,
4701         .vop_readlink           = xfs_readlink,
4702         .vop_fsync              = xfs_fsync,
4703         .vop_inactive           = xfs_inactive,
4704         .vop_fid2               = xfs_fid2,
4705         .vop_rwlock             = xfs_rwlock,
4706         .vop_rwunlock           = xfs_rwunlock,
4707         .vop_bmap               = xfs_bmap,
4708         .vop_reclaim            = xfs_reclaim,
4709         .vop_attr_get           = xfs_attr_get,
4710         .vop_attr_set           = xfs_attr_set,
4711         .vop_attr_remove        = xfs_attr_remove,
4712         .vop_attr_list          = xfs_attr_list,
4713         .vop_link_removed       = (vop_link_removed_t)fs_noval,
4714         .vop_vnode_change       = (vop_vnode_change_t)fs_noval,
4715         .vop_tosspages          = fs_tosspages,
4716         .vop_flushinval_pages   = fs_flushinval_pages,
4717         .vop_flush_pages        = fs_flush_pages,
4718         .vop_release            = xfs_release,
4719         .vop_iflush             = xfs_inode_flush,
4720 };