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 = ip->i_d.di_size;
 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_d.di_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_d.di_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_d.di_size) {
 658                         xfs_igrow_finish(tp, ip, vap->va_size,
 659                             !(flags & ATTR_DMI));
 660                 } else if ((vap->va_size <= ip->i_d.di_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_d.di_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                 xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
1261                                     ip->i_d.di_size);
1262
1263                 error = xfs_trans_reserve(tp, 0,
1264                                           XFS_ITRUNCATE_LOG_RES(mp),
1265                                           0, XFS_TRANS_PERM_LOG_RES,
1266                                           XFS_ITRUNCATE_LOG_COUNT);
1267                 if (error) {
1268                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1269                         xfs_trans_cancel(tp, 0);
1270                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1271                         return error;
1272                 }
1273
1274                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1275                 xfs_trans_ijoin(tp, ip,
1276                                 XFS_IOLOCK_EXCL |
1277                                 XFS_ILOCK_EXCL);
1278                 xfs_trans_ihold(tp, ip);
1279
1280                 error = xfs_itruncate_finish(&tp, ip,
1281                                              ip->i_d.di_size,
1282                                              XFS_DATA_FORK,
1283                                              0);
1284                 /*
1285                  * If we get an error at this point we
1286                  * simply don't bother truncating the file.
1287                  */
1288                 if (error) {
1289                         xfs_trans_cancel(tp,
1290                                          (XFS_TRANS_RELEASE_LOG_RES |
1291                                           XFS_TRANS_ABORT));
1292                 } else {
1293                         error = xfs_trans_commit(tp,
1294                                                 XFS_TRANS_RELEASE_LOG_RES);
1295                 }
1296                 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1297         }
1298         return error;
1299 }
1300
1301 /*
1302  * Free a symlink that has blocks associated with it.
1303  */
1304 STATIC int
1305 xfs_inactive_symlink_rmt(
1306         xfs_inode_t     *ip,
1307         xfs_trans_t     **tpp)
1308 {
1309         xfs_buf_t       *bp;
1310         int             committed;
1311         int             done;
1312         int             error;
1313         xfs_fsblock_t   first_block;
1314         xfs_bmap_free_t free_list;
1315         int             i;
1316         xfs_mount_t     *mp;
1317         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
1318         int             nmaps;
1319         xfs_trans_t     *ntp;
1320         int             size;
1321         xfs_trans_t     *tp;
1322
1323         tp = *tpp;
1324         mp = ip->i_mount;
1325         ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
1326         /*
1327          * We're freeing a symlink that has some
1328          * blocks allocated to it.  Free the
1329          * blocks here.  We know that we've got
1330          * either 1 or 2 extents and that we can
1331          * free them all in one bunmapi call.
1332          */
1333         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
1334         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1335                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1336                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1337                 xfs_trans_cancel(tp, 0);
1338                 *tpp = NULL;
1339                 return error;
1340         }
1341         /*
1342          * Lock the inode, fix the size, and join it to the transaction.
1343          * Hold it so in the normal path, we still have it locked for
1344          * the second transaction.  In the error paths we need it
1345          * held so the cancel won't rele it, see below.
1346          */
1347         xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1348         size = (int)ip->i_d.di_size;
1349         ip->i_d.di_size = 0;
1350         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1351         xfs_trans_ihold(tp, ip);
1352         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1353         /*
1354          * Find the block(s) so we can inval and unmap them.
1355          */
1356         done = 0;
1357         XFS_BMAP_INIT(&free_list, &first_block);
1358         nmaps = ARRAY_SIZE(mval);
1359         if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
1360                         XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
1361                         &free_list, NULL)))
1362                 goto error0;
1363         /*
1364          * Invalidate the block(s).
1365          */
1366         for (i = 0; i < nmaps; i++) {
1367                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
1368                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
1369                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
1370                 xfs_trans_binval(tp, bp);
1371         }
1372         /*
1373          * Unmap the dead block(s) to the free_list.
1374          */
1375         if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
1376                         &first_block, &free_list, NULL, &done)))
1377                 goto error1;
1378         ASSERT(done);
1379         /*
1380          * Commit the first transaction.  This logs the EFI and the inode.
1381          */
1382         if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
1383                 goto error1;
1384         /*
1385          * The transaction must have been committed, since there were
1386          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
1387          * The new tp has the extent freeing and EFDs.
1388          */
1389         ASSERT(committed);
1390         /*
1391          * The first xact was committed, so add the inode to the new one.
1392          * Mark it dirty so it will be logged and moved forward in the log as
1393          * part of every commit.
1394          */
1395         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1396         xfs_trans_ihold(tp, ip);
1397         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1398         /*
1399          * Get a new, empty transaction to return to our caller.
1400          */
1401         ntp = xfs_trans_dup(tp);
1402         /*
1403          * Commit the transaction containing extent freeing and EFDs.
1404          * If we get an error on the commit here or on the reserve below,
1405          * we need to unlock the inode since the new transaction doesn't
1406          * have the inode attached.
1407          */
1408         error = xfs_trans_commit(tp, 0);
1409         tp = ntp;
1410         if (error) {
1411                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1412                 goto error0;
1413         }
1414         /*
1415          * Remove the memory for extent descriptions (just bookkeeping).
1416          */
1417         if (ip->i_df.if_bytes)
1418                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
1419         ASSERT(ip->i_df.if_bytes == 0);
1420         /*
1421          * Put an itruncate log reservation in the new transaction
1422          * for our caller.
1423          */
1424         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1425                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1426                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1427                 goto error0;
1428         }
1429         /*
1430          * Return with the inode locked but not joined to the transaction.
1431          */
1432         *tpp = tp;
1433         return 0;
1434
1435  error1:
1436         xfs_bmap_cancel(&free_list);
1437  error0:
1438         /*
1439          * Have to come here with the inode locked and either
1440          * (held and in the transaction) or (not in the transaction).
1441          * If the inode isn't held then cancel would iput it, but
1442          * that's wrong since this is inactive and the vnode ref
1443          * count is 0 already.
1444          * Cancel won't do anything to the inode if held, but it still
1445          * needs to be locked until the cancel is done, if it was
1446          * joined to the transaction.
1447          */
1448         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1449         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1450         *tpp = NULL;
1451         return error;
1452
1453 }
1454
1455 STATIC int
1456 xfs_inactive_symlink_local(
1457         xfs_inode_t     *ip,
1458         xfs_trans_t     **tpp)
1459 {
1460         int             error;
1461
1462         ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
1463         /*
1464          * We're freeing a symlink which fit into
1465          * the inode.  Just free the memory used
1466          * to hold the old symlink.
1467          */
1468         error = xfs_trans_reserve(*tpp, 0,
1469                                   XFS_ITRUNCATE_LOG_RES(ip->i_mount),
1470                                   0, XFS_TRANS_PERM_LOG_RES,
1471                                   XFS_ITRUNCATE_LOG_COUNT);
1472
1473         if (error) {
1474                 xfs_trans_cancel(*tpp, 0);
1475                 *tpp = NULL;
1476                 return error;
1477         }
1478         xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1479
1480         /*
1481          * Zero length symlinks _can_ exist.
1482          */
1483         if (ip->i_df.if_bytes > 0) {
1484                 xfs_idata_realloc(ip,
1485                                   -(ip->i_df.if_bytes),
1486                                   XFS_DATA_FORK);
1487                 ASSERT(ip->i_df.if_bytes == 0);
1488         }
1489         return 0;
1490 }
1491
1492 STATIC int
1493 xfs_inactive_attrs(
1494         xfs_inode_t     *ip,
1495         xfs_trans_t     **tpp)
1496 {
1497         xfs_trans_t     *tp;
1498         int             error;
1499         xfs_mount_t     *mp;
1500
1501         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
1502         tp = *tpp;
1503         mp = ip->i_mount;
1504         ASSERT(ip->i_d.di_forkoff != 0);
1505         xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1506         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1507
1508         error = xfs_attr_inactive(ip);
1509         if (error) {
1510                 *tpp = NULL;
1511                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1512                 return error; /* goto out */
1513         }
1514
1515         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1516         error = xfs_trans_reserve(tp, 0,
1517                                   XFS_IFREE_LOG_RES(mp),
1518                                   0, XFS_TRANS_PERM_LOG_RES,
1519                                   XFS_INACTIVE_LOG_COUNT);
1520         if (error) {
1521                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1522                 xfs_trans_cancel(tp, 0);
1523                 *tpp = NULL;
1524                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1525                 return error;
1526         }
1527
1528         xfs_ilock(ip, XFS_ILOCK_EXCL);
1529         xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1530         xfs_trans_ihold(tp, ip);
1531         xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1532
1533         ASSERT(ip->i_d.di_anextents == 0);
1534
1535         *tpp = tp;
1536         return 0;
1537 }
1538
1539 STATIC int
1540 xfs_release(
1541         bhv_desc_t      *bdp)
1542 {
1543         xfs_inode_t     *ip;
1544         bhv_vnode_t     *vp;
1545         xfs_mount_t     *mp;
1546         int             error;
1547
1548         vp = BHV_TO_VNODE(bdp);
1549         ip = XFS_BHVTOI(bdp);
1550         mp = ip->i_mount;
1551
1552         if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0))
1553                 return 0;
1554
1555         /* If this is a read-only mount, don't do this (would generate I/O) */
1556         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1557                 return 0;
1558
1559 #ifdef HAVE_REFCACHE
1560         /* If we are in the NFS reference cache then don't do this now */
1561         if (ip->i_refcache)
1562                 return 0;
1563 #endif
1564
1565         if (ip->i_d.di_nlink != 0) {
1566                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1567                      ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
1568                        ip->i_delayed_blks > 0)) &&
1569                      (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
1570                     (!(ip->i_d.di_flags &
1571                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
1572                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
1573                                 return error;
1574                         /* Update linux inode block count after free above */
1575                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1576                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1577                 }
1578         }
1579
1580         return 0;
1581 }
1582
1583 /*
1584  * xfs_inactive
1585  *
1586  * This is called when the vnode reference count for the vnode
1587  * goes to zero.  If the file has been unlinked, then it must
1588  * now be truncated.  Also, we clear all of the read-ahead state
1589  * kept for the inode here since the file is now closed.
1590  */
1591 STATIC int
1592 xfs_inactive(
1593         bhv_desc_t      *bdp,
1594         cred_t          *credp)
1595 {
1596         xfs_inode_t     *ip;
1597         bhv_vnode_t     *vp;
1598         xfs_bmap_free_t free_list;
1599         xfs_fsblock_t   first_block;
1600         int             committed;
1601         xfs_trans_t     *tp;
1602         xfs_mount_t     *mp;
1603         int             error;
1604         int             truncate;
1605
1606         vp = BHV_TO_VNODE(bdp);
1607         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
1608
1609         ip = XFS_BHVTOI(bdp);
1610
1611         /*
1612          * If the inode is already free, then there can be nothing
1613          * to clean up here.
1614          */
1615         if (ip->i_d.di_mode == 0 || VN_BAD(vp)) {
1616                 ASSERT(ip->i_df.if_real_bytes == 0);
1617                 ASSERT(ip->i_df.if_broot_bytes == 0);
1618                 return VN_INACTIVE_CACHE;
1619         }
1620
1621         /*
1622          * Only do a truncate if it's a regular file with
1623          * some actual space in it.  It's OK to look at the
1624          * inode's fields without the lock because we're the
1625          * only one with a reference to the inode.
1626          */
1627         truncate = ((ip->i_d.di_nlink == 0) &&
1628             ((ip->i_d.di_size != 0) || (ip->i_d.di_nextents > 0) ||
1629              (ip->i_delayed_blks > 0)) &&
1630             ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
1631
1632         mp = ip->i_mount;
1633
1634         if (ip->i_d.di_nlink == 0 &&
1635             DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_DESTROY)) {
1636                 (void) XFS_SEND_DESTROY(mp, vp, DM_RIGHT_NULL);
1637         }
1638
1639         error = 0;
1640
1641         /* If this is a read-only mount, don't do this (would generate I/O) */
1642         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1643                 goto out;
1644
1645         if (ip->i_d.di_nlink != 0) {
1646                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1647                      ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
1648                        ip->i_delayed_blks > 0)) &&
1649                       (ip->i_df.if_flags & XFS_IFEXTENTS) &&
1650                      (!(ip->i_d.di_flags &
1651                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
1652                       (ip->i_delayed_blks != 0)))) {
1653                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
1654                                 return VN_INACTIVE_CACHE;
1655                         /* Update linux inode block count after free above */
1656                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1657                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1658                 }
1659                 goto out;
1660         }
1661
1662         ASSERT(ip->i_d.di_nlink == 0);
1663
1664         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
1665                 return VN_INACTIVE_CACHE;
1666
1667         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1668         if (truncate) {
1669                 /*
1670                  * Do the xfs_itruncate_start() call before
1671                  * reserving any log space because itruncate_start
1672                  * will call into the buffer cache and we can't
1673                  * do that within a transaction.
1674                  */
1675                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1676
1677                 xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
1678
1679                 error = xfs_trans_reserve(tp, 0,
1680                                           XFS_ITRUNCATE_LOG_RES(mp),
1681                                           0, XFS_TRANS_PERM_LOG_RES,
1682                                           XFS_ITRUNCATE_LOG_COUNT);
1683                 if (error) {
1684                         /* Don't call itruncate_cleanup */
1685                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1686                         xfs_trans_cancel(tp, 0);
1687                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1688                         return VN_INACTIVE_CACHE;
1689                 }
1690
1691                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1692                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1693                 xfs_trans_ihold(tp, ip);
1694
1695                 /*
1696                  * normally, we have to run xfs_itruncate_finish sync.
1697                  * But if filesystem is wsync and we're in the inactive
1698                  * path, then we know that nlink == 0, and that the
1699                  * xaction that made nlink == 0 is permanently committed
1700                  * since xfs_remove runs as a synchronous transaction.
1701                  */
1702                 error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK,
1703                                 (!(mp->m_flags & XFS_MOUNT_WSYNC) ? 1 : 0));
1704
1705                 if (error) {
1706                         xfs_trans_cancel(tp,
1707                                 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1708                         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1709                         return VN_INACTIVE_CACHE;
1710                 }
1711         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
1712
1713                 /*
1714                  * If we get an error while cleaning up a
1715                  * symlink we bail out.
1716                  */
1717                 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
1718                         xfs_inactive_symlink_rmt(ip, &tp) :
1719                         xfs_inactive_symlink_local(ip, &tp);
1720
1721                 if (error) {
1722                         ASSERT(tp == NULL);
1723                         return VN_INACTIVE_CACHE;
1724                 }
1725
1726                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1727                 xfs_trans_ihold(tp, ip);
1728         } else {
1729                 error = xfs_trans_reserve(tp, 0,
1730                                           XFS_IFREE_LOG_RES(mp),
1731                                           0, XFS_TRANS_PERM_LOG_RES,
1732                                           XFS_INACTIVE_LOG_COUNT);
1733                 if (error) {
1734                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1735                         xfs_trans_cancel(tp, 0);
1736                         return VN_INACTIVE_CACHE;
1737                 }
1738
1739                 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1740                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1741                 xfs_trans_ihold(tp, ip);
1742         }
1743
1744         /*
1745          * If there are attributes associated with the file
1746          * then blow them away now.  The code calls a routine
1747          * that recursively deconstructs the attribute fork.
1748          * We need to just commit the current transaction
1749          * because we can't use it for xfs_attr_inactive().
1750          */
1751         if (ip->i_d.di_anextents > 0) {
1752                 error = xfs_inactive_attrs(ip, &tp);
1753                 /*
1754                  * If we got an error, the transaction is already
1755                  * cancelled, and the inode is unlocked. Just get out.
1756                  */
1757                  if (error)
1758                          return VN_INACTIVE_CACHE;
1759         } else if (ip->i_afp) {
1760                 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1761         }
1762
1763         /*
1764          * Free the inode.
1765          */
1766         XFS_BMAP_INIT(&free_list, &first_block);
1767         error = xfs_ifree(tp, ip, &free_list);
1768         if (error) {
1769                 /*
1770                  * If we fail to free the inode, shut down.  The cancel
1771                  * might do that, we need to make sure.  Otherwise the
1772                  * inode might be lost for a long time or forever.
1773                  */
1774                 if (!XFS_FORCED_SHUTDOWN(mp)) {
1775                         cmn_err(CE_NOTE,
1776                 "xfs_inactive:  xfs_ifree() returned an error = %d on %s",
1777                                 error, mp->m_fsname);
1778                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1779                 }
1780                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
1781         } else {
1782                 /*
1783                  * Credit the quota account(s). The inode is gone.
1784                  */
1785                 XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1786
1787                 /*
1788                  * Just ignore errors at this point.  There is
1789                  * nothing we can do except to try to keep going.
1790                  */
1791                 (void) xfs_bmap_finish(&tp,  &free_list, &committed);
1792                 (void) xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1793         }
1794         /*
1795          * Release the dquots held by inode, if any.
1796          */
1797         XFS_QM_DQDETACH(mp, ip);
1798
1799         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1800
1801  out:
1802         return VN_INACTIVE_CACHE;
1803 }
1804
1805
1806 /*
1807  * xfs_lookup
1808  */
1809 STATIC int
1810 xfs_lookup(
1811         bhv_desc_t              *dir_bdp,
1812         bhv_vname_t             *dentry,
1813         bhv_vnode_t             **vpp,
1814         int                     flags,
1815         bhv_vnode_t             *rdir,
1816         cred_t                  *credp)
1817 {
1818         xfs_inode_t             *dp, *ip;
1819         xfs_ino_t               e_inum;
1820         int                     error;
1821         uint                    lock_mode;
1822         bhv_vnode_t             *dir_vp;
1823
1824         dir_vp = BHV_TO_VNODE(dir_bdp);
1825         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1826
1827         dp = XFS_BHVTOI(dir_bdp);
1828
1829         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
1830                 return XFS_ERROR(EIO);
1831
1832         lock_mode = xfs_ilock_map_shared(dp);
1833         error = xfs_dir_lookup_int(dir_bdp, lock_mode, dentry, &e_inum, &ip);
1834         if (!error) {
1835                 *vpp = XFS_ITOV(ip);
1836                 ITRACE(ip);
1837         }
1838         xfs_iunlock_map_shared(dp, lock_mode);
1839         return error;
1840 }
1841
1842
1843 /*
1844  * xfs_create (create a new file).
1845  */
1846 STATIC int
1847 xfs_create(
1848         bhv_desc_t              *dir_bdp,
1849         bhv_vname_t             *dentry,
1850         bhv_vattr_t             *vap,
1851         bhv_vnode_t             **vpp,
1852         cred_t                  *credp)
1853 {
1854         char                    *name = VNAME(dentry);
1855         bhv_vnode_t             *dir_vp;
1856         xfs_inode_t             *dp, *ip;
1857         bhv_vnode_t             *vp = NULL;
1858         xfs_trans_t             *tp;
1859         xfs_mount_t             *mp;
1860         xfs_dev_t               rdev;
1861         int                     error;
1862         xfs_bmap_free_t         free_list;
1863         xfs_fsblock_t           first_block;
1864         boolean_t               dp_joined_to_trans;
1865         int                     dm_event_sent = 0;
1866         uint                    cancel_flags;
1867         int                     committed;
1868         xfs_prid_t              prid;
1869         struct xfs_dquot        *udqp, *gdqp;
1870         uint                    resblks;
1871         int                     dm_di_mode;
1872         int                     namelen;
1873
1874         ASSERT(!*vpp);
1875         dir_vp = BHV_TO_VNODE(dir_bdp);
1876         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1877
1878         dp = XFS_BHVTOI(dir_bdp);
1879         mp = dp->i_mount;
1880
1881         dm_di_mode = vap->va_mode;
1882         namelen = VNAMELEN(dentry);
1883
1884         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
1885                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
1886                                 dir_vp, DM_RIGHT_NULL, NULL,
1887                                 DM_RIGHT_NULL, name, NULL,
1888                                 dm_di_mode, 0, 0);
1889
1890                 if (error)
1891                         return error;
1892                 dm_event_sent = 1;
1893         }
1894
1895         if (XFS_FORCED_SHUTDOWN(mp))
1896                 return XFS_ERROR(EIO);
1897
1898         /* Return through std_return after this point. */
1899
1900         udqp = gdqp = NULL;
1901         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1902                 prid = dp->i_d.di_projid;
1903         else if (vap->va_mask & XFS_AT_PROJID)
1904                 prid = (xfs_prid_t)vap->va_projid;
1905         else
1906                 prid = (xfs_prid_t)dfltprid;
1907
1908         /*
1909          * Make sure that we have allocated dquot(s) on disk.
1910          */
1911         error = XFS_QM_DQVOPALLOC(mp, dp,
1912                         current_fsuid(credp), current_fsgid(credp), prid,
1913                         XFS_QMOPT_QUOTALL|XFS_QMOPT_INHERIT, &udqp, &gdqp);
1914         if (error)
1915                 goto std_return;
1916
1917         ip = NULL;
1918         dp_joined_to_trans = B_FALSE;
1919
1920         tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
1921         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1922         resblks = XFS_CREATE_SPACE_RES(mp, namelen);
1923         /*
1924          * Initially assume that the file does not exist and
1925          * reserve the resources for that case.  If that is not
1926          * the case we'll drop the one we have and get a more
1927          * appropriate transaction later.
1928          */
1929         error = xfs_trans_reserve(tp, resblks, XFS_CREATE_LOG_RES(mp), 0,
1930                         XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1931         if (error == ENOSPC) {
1932                 resblks = 0;
1933                 error = xfs_trans_reserve(tp, 0, XFS_CREATE_LOG_RES(mp), 0,
1934                                 XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1935         }
1936         if (error) {
1937                 cancel_flags = 0;
1938                 dp = NULL;
1939                 goto error_return;
1940         }
1941
1942         xfs_ilock(dp, XFS_ILOCK_EXCL);
1943
1944         XFS_BMAP_INIT(&free_list, &first_block);
1945
1946         ASSERT(ip == NULL);
1947
1948         /*
1949          * Reserve disk quota and the inode.
1950          */
1951         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
1952         if (error)
1953                 goto error_return;
1954
1955         if (resblks == 0 && (error = xfs_dir_canenter(tp, dp, name, namelen)))
1956                 goto error_return;
1957         rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
1958         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
1959                         rdev, credp, prid, resblks > 0,
1960                         &ip, &committed);
1961         if (error) {
1962                 if (error == ENOSPC)
1963                         goto error_return;
1964                 goto abort_return;
1965         }
1966         ITRACE(ip);
1967
1968         /*
1969          * At this point, we've gotten a newly allocated inode.
1970          * It is locked (and joined to the transaction).
1971          */
1972
1973         ASSERT(ismrlocked (&ip->i_lock, MR_UPDATE));
1974
1975         /*
1976          * Now we join the directory inode to the transaction.
1977          * We do not do it earlier because xfs_dir_ialloc
1978          * might commit the previous transaction (and release
1979          * all the locks).
1980          */
1981
1982         VN_HOLD(dir_vp);
1983         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1984         dp_joined_to_trans = B_TRUE;
1985
1986         error = xfs_dir_createname(tp, dp, name, namelen, ip->i_ino,
1987                                         &first_block, &free_list, resblks ?
1988                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1989         if (error) {
1990                 ASSERT(error != ENOSPC);
1991                 goto abort_return;
1992         }
1993         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1994         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1995
1996         /*
1997          * If this is a synchronous mount, make sure that the
1998          * create transaction goes to disk before returning to
1999          * the user.
2000          */
2001         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2002                 xfs_trans_set_sync(tp);
2003         }
2004
2005         dp->i_gen++;
2006
2007         /*
2008          * Attach the dquot(s) to the inodes and modify them incore.
2009          * These ids of the inode couldn't have changed since the new
2010          * inode has been locked ever since it was created.
2011          */
2012         XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
2013
2014         /*
2015          * xfs_trans_commit normally decrements the vnode ref count
2016          * when it unlocks the inode. Since we want to return the
2017          * vnode to the caller, we bump the vnode ref count now.
2018          */
2019         IHOLD(ip);
2020         vp = XFS_ITOV(ip);
2021
2022         error = xfs_bmap_finish(&tp, &free_list, &committed);
2023         if (error) {
2024                 xfs_bmap_cancel(&free_list);
2025                 goto abort_rele;
2026         }
2027
2028         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2029         if (error) {
2030                 IRELE(ip);
2031                 tp = NULL;
2032                 goto error_return;
2033         }
2034
2035         XFS_QM_DQRELE(mp, udqp);
2036         XFS_QM_DQRELE(mp, gdqp);
2037
2038         /*
2039          * Propagate the fact that the vnode changed after the
2040          * xfs_inode locks have been released.
2041          */
2042         bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
2043
2044         *vpp = vp;
2045
2046         /* Fallthrough to std_return with error = 0  */
2047
2048 std_return:
2049         if ( (*vpp || (error != 0 && dm_event_sent != 0)) &&
2050                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2051                                                         DM_EVENT_POSTCREATE)) {
2052                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2053                         dir_vp, DM_RIGHT_NULL,
2054                         *vpp ? vp:NULL,
2055                         DM_RIGHT_NULL, name, NULL,
2056                         dm_di_mode, error, 0);
2057         }
2058         return error;
2059
2060  abort_return:
2061         cancel_flags |= XFS_TRANS_ABORT;
2062         /* FALLTHROUGH */
2063
2064  error_return:
2065         if (tp != NULL)
2066                 xfs_trans_cancel(tp, cancel_flags);
2067
2068         if (!dp_joined_to_trans && (dp != NULL))
2069                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2070         XFS_QM_DQRELE(mp, udqp);
2071         XFS_QM_DQRELE(mp, gdqp);
2072
2073         goto std_return;
2074
2075  abort_rele:
2076         /*
2077          * Wait until after the current transaction is aborted to
2078          * release the inode.  This prevents recursive transactions
2079          * and deadlocks from xfs_inactive.
2080          */
2081         cancel_flags |= XFS_TRANS_ABORT;
2082         xfs_trans_cancel(tp, cancel_flags);
2083         IRELE(ip);
2084
2085         XFS_QM_DQRELE(mp, udqp);
2086         XFS_QM_DQRELE(mp, gdqp);
2087
2088         goto std_return;
2089 }
2090
2091 #ifdef DEBUG
2092 /*
2093  * Some counters to see if (and how often) we are hitting some deadlock
2094  * prevention code paths.
2095  */
2096
2097 int xfs_rm_locks;
2098 int xfs_rm_lock_delays;
2099 int xfs_rm_attempts;
2100 #endif
2101
2102 /*
2103  * The following routine will lock the inodes associated with the
2104  * directory and the named entry in the directory. The locks are
2105  * acquired in increasing inode number.
2106  *
2107  * If the entry is "..", then only the directory is locked. The
2108  * vnode ref count will still include that from the .. entry in
2109  * this case.
2110  *
2111  * There is a deadlock we need to worry about. If the locked directory is
2112  * in the AIL, it might be blocking up the log. The next inode we lock
2113  * could be already locked by another thread waiting for log space (e.g
2114  * a permanent log reservation with a long running transaction (see
2115  * xfs_itruncate_finish)). To solve this, we must check if the directory
2116  * is in the ail and use lock_nowait. If we can't lock, we need to
2117  * drop the inode lock on the directory and try again. xfs_iunlock will
2118  * potentially push the tail if we were holding up the log.
2119  */
2120 STATIC int
2121 xfs_lock_dir_and_entry(
2122         xfs_inode_t     *dp,
2123         bhv_vname_t     *dentry,
2124         xfs_inode_t     *ip)    /* inode of entry 'name' */
2125 {
2126         int             attempts;
2127         xfs_ino_t       e_inum;
2128         xfs_inode_t     *ips[2];
2129         xfs_log_item_t  *lp;
2130
2131 #ifdef DEBUG
2132         xfs_rm_locks++;
2133 #endif
2134         attempts = 0;
2135
2136 again:
2137         xfs_ilock(dp, XFS_ILOCK_EXCL);
2138
2139         e_inum = ip->i_ino;
2140
2141         ITRACE(ip);
2142
2143         /*
2144          * We want to lock in increasing inum. Since we've already
2145          * acquired the lock on the directory, we may need to release
2146          * if if the inum of the entry turns out to be less.
2147          */
2148         if (e_inum > dp->i_ino) {
2149                 /*
2150                  * We are already in the right order, so just
2151                  * lock on the inode of the entry.
2152                  * We need to use nowait if dp is in the AIL.
2153                  */
2154
2155                 lp = (xfs_log_item_t *)dp->i_itemp;
2156                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2157                         if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2158                                 attempts++;
2159 #ifdef DEBUG
2160                                 xfs_rm_attempts++;
2161 #endif
2162
2163                                 /*
2164                                  * Unlock dp and try again.
2165                                  * xfs_iunlock will try to push the tail
2166                                  * if the inode is in the AIL.
2167                                  */
2168
2169                                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2170
2171                                 if ((attempts % 5) == 0) {
2172                                         delay(1); /* Don't just spin the CPU */
2173 #ifdef DEBUG
2174                                         xfs_rm_lock_delays++;
2175 #endif
2176                                 }
2177                                 goto again;
2178                         }
2179                 } else {
2180                         xfs_ilock(ip, XFS_ILOCK_EXCL);
2181                 }
2182         } else if (e_inum < dp->i_ino) {
2183                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2184
2185                 ips[0] = ip;
2186                 ips[1] = dp;
2187                 xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2188         }
2189         /* else  e_inum == dp->i_ino */
2190         /*     This can happen if we're asked to lock /x/..
2191          *     the entry is "..", which is also the parent directory.
2192          */
2193
2194         return 0;
2195 }
2196
2197 #ifdef DEBUG
2198 int xfs_locked_n;
2199 int xfs_small_retries;
2200 int xfs_middle_retries;
2201 int xfs_lots_retries;
2202 int xfs_lock_delays;
2203 #endif
2204
2205 /*
2206  * The following routine will lock n inodes in exclusive mode.
2207  * We assume the caller calls us with the inodes in i_ino order.
2208  *
2209  * We need to detect deadlock where an inode that we lock
2210  * is in the AIL and we start waiting for another inode that is locked
2211  * by a thread in a long running transaction (such as truncate). This can
2212  * result in deadlock since the long running trans might need to wait
2213  * for the inode we just locked in order to push the tail and free space
2214  * in the log.
2215  */
2216 void
2217 xfs_lock_inodes(
2218         xfs_inode_t     **ips,
2219         int             inodes,
2220         int             first_locked,
2221         uint            lock_mode)
2222 {
2223         int             attempts = 0, i, j, try_lock;
2224         xfs_log_item_t  *lp;
2225
2226         ASSERT(ips && (inodes >= 2)); /* we need at least two */
2227
2228         if (first_locked) {
2229                 try_lock = 1;
2230                 i = 1;
2231         } else {
2232                 try_lock = 0;
2233                 i = 0;
2234         }
2235
2236 again:
2237         for (; i < inodes; i++) {
2238                 ASSERT(ips[i]);
2239
2240                 if (i && (ips[i] == ips[i-1]))  /* Already locked */
2241                         continue;
2242
2243                 /*
2244                  * If try_lock is not set yet, make sure all locked inodes
2245                  * are not in the AIL.
2246                  * If any are, set try_lock to be used later.
2247                  */
2248
2249                 if (!try_lock) {
2250                         for (j = (i - 1); j >= 0 && !try_lock; j--) {
2251                                 lp = (xfs_log_item_t *)ips[j]->i_itemp;
2252                                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2253                                         try_lock++;
2254                                 }
2255                         }
2256                 }
2257
2258                 /*
2259                  * If any of the previous locks we have locked is in the AIL,
2260                  * we must TRY to get the second and subsequent locks. If
2261                  * we can't get any, we must release all we have
2262                  * and try again.
2263                  */
2264
2265                 if (try_lock) {
2266                         /* try_lock must be 0 if i is 0. */
2267                         /*
2268                          * try_lock means we have an inode locked
2269                          * that is in the AIL.
2270                          */
2271                         ASSERT(i != 0);
2272                         if (!xfs_ilock_nowait(ips[i], lock_mode)) {
2273                                 attempts++;
2274
2275                                 /*
2276                                  * Unlock all previous guys and try again.
2277                                  * xfs_iunlock will try to push the tail
2278                                  * if the inode is in the AIL.
2279                                  */
2280
2281                                 for(j = i - 1; j >= 0; j--) {
2282
2283                                         /*
2284                                          * Check to see if we've already
2285                                          * unlocked this one.
2286                                          * Not the first one going back,
2287                                          * and the inode ptr is the same.
2288                                          */
2289                                         if ((j != (i - 1)) && ips[j] ==
2290                                                                 ips[j+1])
2291                                                 continue;
2292
2293                                         xfs_iunlock(ips[j], lock_mode);
2294                                 }
2295
2296                                 if ((attempts % 5) == 0) {
2297                                         delay(1); /* Don't just spin the CPU */
2298 #ifdef DEBUG
2299                                         xfs_lock_delays++;
2300 #endif
2301                                 }
2302                                 i = 0;
2303                                 try_lock = 0;
2304                                 goto again;
2305                         }
2306                 } else {
2307                         xfs_ilock(ips[i], lock_mode);
2308                 }
2309         }
2310
2311 #ifdef DEBUG
2312         if (attempts) {
2313                 if (attempts < 5) xfs_small_retries++;
2314                 else if (attempts < 100) xfs_middle_retries++;
2315                 else xfs_lots_retries++;
2316         } else {
2317                 xfs_locked_n++;
2318         }
2319 #endif
2320 }
2321
2322 #ifdef  DEBUG
2323 #define REMOVE_DEBUG_TRACE(x)   {remove_which_error_return = (x);}
2324 int remove_which_error_return = 0;
2325 #else /* ! DEBUG */
2326 #define REMOVE_DEBUG_TRACE(x)
2327 #endif  /* ! DEBUG */
2328
2329
2330 /*
2331  * xfs_remove
2332  *
2333  */
2334 STATIC int
2335 xfs_remove(
2336         bhv_desc_t              *dir_bdp,
2337         bhv_vname_t             *dentry,
2338         cred_t                  *credp)
2339 {
2340         bhv_vnode_t             *dir_vp;
2341         char                    *name = VNAME(dentry);
2342         xfs_inode_t             *dp, *ip;
2343         xfs_trans_t             *tp = NULL;
2344         xfs_mount_t             *mp;
2345         int                     error = 0;
2346         xfs_bmap_free_t         free_list;
2347         xfs_fsblock_t           first_block;
2348         int                     cancel_flags;
2349         int                     committed;
2350         int                     dm_di_mode = 0;
2351         int                     link_zero;
2352         uint                    resblks;
2353         int                     namelen;
2354
2355         dir_vp = BHV_TO_VNODE(dir_bdp);
2356         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2357
2358         dp = XFS_BHVTOI(dir_bdp);
2359         mp = dp->i_mount;
2360
2361         if (XFS_FORCED_SHUTDOWN(mp))
2362                 return XFS_ERROR(EIO);
2363
2364         namelen = VNAMELEN(dentry);
2365
2366         if (!xfs_get_dir_entry(dentry, &ip)) {
2367                 dm_di_mode = ip->i_d.di_mode;
2368                 IRELE(ip);
2369         }
2370
2371         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
2372                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE, dir_vp,
2373                                         DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
2374                                         name, NULL, dm_di_mode, 0, 0);
2375                 if (error)
2376                         return error;
2377         }
2378
2379         /* From this point on, return through std_return */
2380         ip = NULL;
2381
2382         /*
2383          * We need to get a reference to ip before we get our log
2384          * reservation. The reason for this is that we cannot call
2385          * xfs_iget for an inode for which we do not have a reference
2386          * once we've acquired a log reservation. This is because the
2387          * inode we are trying to get might be in xfs_inactive going
2388          * for a log reservation. Since we'll have to wait for the
2389          * inactive code to complete before returning from xfs_iget,
2390          * we need to make sure that we don't have log space reserved
2391          * when we call xfs_iget.  Instead we get an unlocked reference
2392          * to the inode before getting our log reservation.
2393          */
2394         error = xfs_get_dir_entry(dentry, &ip);
2395         if (error) {
2396                 REMOVE_DEBUG_TRACE(__LINE__);
2397                 goto std_return;
2398         }
2399
2400         dm_di_mode = ip->i_d.di_mode;
2401
2402         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2403
2404         ITRACE(ip);
2405
2406         error = XFS_QM_DQATTACH(mp, dp, 0);
2407         if (!error && dp != ip)
2408                 error = XFS_QM_DQATTACH(mp, ip, 0);
2409         if (error) {
2410                 REMOVE_DEBUG_TRACE(__LINE__);
2411                 IRELE(ip);
2412                 goto std_return;
2413         }
2414
2415         tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
2416         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2417         /*
2418          * We try to get the real space reservation first,
2419          * allowing for directory btree deletion(s) implying
2420          * possible bmap insert(s).  If we can't get the space
2421          * reservation then we use 0 instead, and avoid the bmap
2422          * btree insert(s) in the directory code by, if the bmap
2423          * insert tries to happen, instead trimming the LAST
2424          * block from the directory.
2425          */
2426         resblks = XFS_REMOVE_SPACE_RES(mp);
2427         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
2428                         XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2429         if (error == ENOSPC) {
2430                 resblks = 0;
2431                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
2432                                 XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2433         }
2434         if (error) {
2435                 ASSERT(error != ENOSPC);
2436                 REMOVE_DEBUG_TRACE(__LINE__);
2437                 xfs_trans_cancel(tp, 0);
2438                 IRELE(ip);
2439                 return error;
2440         }
2441
2442         error = xfs_lock_dir_and_entry(dp, dentry, ip);
2443         if (error) {
2444                 REMOVE_DEBUG_TRACE(__LINE__);
2445                 xfs_trans_cancel(tp, cancel_flags);
2446                 IRELE(ip);
2447                 goto std_return;
2448         }
2449
2450         /*
2451          * At this point, we've gotten both the directory and the entry
2452          * inodes locked.
2453          */
2454         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2455         if (dp != ip) {
2456                 /*
2457                  * Increment vnode ref count only in this case since
2458                  * there's an extra vnode reference in the case where
2459                  * dp == ip.
2460                  */
2461                 IHOLD(dp);
2462                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2463         }
2464
2465         /*
2466          * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2467          */
2468         XFS_BMAP_INIT(&free_list, &first_block);
2469         error = xfs_dir_removename(tp, dp, name, namelen, ip->i_ino,
2470                                         &first_block, &free_list, 0);
2471         if (error) {
2472                 ASSERT(error != ENOENT);
2473                 REMOVE_DEBUG_TRACE(__LINE__);
2474                 goto error1;
2475         }
2476         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2477
2478         dp->i_gen++;
2479         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2480
2481         error = xfs_droplink(tp, ip);
2482         if (error) {
2483                 REMOVE_DEBUG_TRACE(__LINE__);
2484                 goto error1;
2485         }
2486
2487         /* Determine if this is the last link while
2488          * we are in the transaction.
2489          */
2490         link_zero = (ip)->i_d.di_nlink==0;
2491
2492         /*
2493          * Take an extra ref on the inode so that it doesn't
2494          * go to xfs_inactive() from within the commit.
2495          */
2496         IHOLD(ip);
2497
2498         /*
2499          * If this is a synchronous mount, make sure that the
2500          * remove transaction goes to disk before returning to
2501          * the user.
2502          */
2503         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2504                 xfs_trans_set_sync(tp);
2505         }
2506
2507         error = xfs_bmap_finish(&tp, &free_list, &committed);
2508         if (error) {
2509                 REMOVE_DEBUG_TRACE(__LINE__);
2510                 goto error_rele;
2511         }
2512
2513         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2514         if (error) {
2515                 IRELE(ip);
2516                 goto std_return;
2517         }
2518
2519         /*
2520          * Before we drop our extra reference to the inode, purge it
2521          * from the refcache if it is there.  By waiting until afterwards
2522          * to do the IRELE, we ensure that we won't go inactive in the
2523          * xfs_refcache_purge_ip routine (although that would be OK).
2524          */
2525         xfs_refcache_purge_ip(ip);
2526
2527         vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2528
2529         /*
2530          * Let interposed file systems know about removed links.
2531          */
2532         bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
2533
2534         IRELE(ip);
2535
2536 /*      Fall through to std_return with error = 0 */
2537  std_return:
2538         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp,
2539                                                 DM_EVENT_POSTREMOVE)) {
2540                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
2541                                 dir_vp, DM_RIGHT_NULL,
2542                                 NULL, DM_RIGHT_NULL,
2543                                 name, NULL, dm_di_mode, error, 0);
2544         }
2545         return error;
2546
2547  error1:
2548         xfs_bmap_cancel(&free_list);
2549         cancel_flags |= XFS_TRANS_ABORT;
2550         xfs_trans_cancel(tp, cancel_flags);
2551         goto std_return;
2552
2553  error_rele:
2554         /*
2555          * In this case make sure to not release the inode until after
2556          * the current transaction is aborted.  Releasing it beforehand
2557          * can cause us to go to xfs_inactive and start a recursive
2558          * transaction which can easily deadlock with the current one.
2559          */
2560         xfs_bmap_cancel(&free_list);
2561         cancel_flags |= XFS_TRANS_ABORT;
2562         xfs_trans_cancel(tp, cancel_flags);
2563
2564         /*
2565          * Before we drop our extra reference to the inode, purge it
2566          * from the refcache if it is there.  By waiting until afterwards
2567          * to do the IRELE, we ensure that we won't go inactive in the
2568          * xfs_refcache_purge_ip routine (although that would be OK).
2569          */
2570         xfs_refcache_purge_ip(ip);
2571
2572         IRELE(ip);
2573
2574         goto std_return;
2575 }
2576
2577
2578 /*
2579  * xfs_link
2580  *
2581  */
2582 STATIC int
2583 xfs_link(
2584         bhv_desc_t              *target_dir_bdp,
2585         bhv_vnode_t             *src_vp,
2586         bhv_vname_t             *dentry,
2587         cred_t                  *credp)
2588 {
2589         xfs_inode_t             *tdp, *sip;
2590         xfs_trans_t             *tp;
2591         xfs_mount_t             *mp;
2592         xfs_inode_t             *ips[2];
2593         int                     error;
2594         xfs_bmap_free_t         free_list;
2595         xfs_fsblock_t           first_block;
2596         int                     cancel_flags;
2597         int                     committed;
2598         bhv_vnode_t             *target_dir_vp;
2599         int                     resblks;
2600         char                    *target_name = VNAME(dentry);
2601         int                     target_namelen;
2602
2603         target_dir_vp = BHV_TO_VNODE(target_dir_bdp);
2604         vn_trace_entry(target_dir_vp, __FUNCTION__, (inst_t *)__return_address);
2605         vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address);
2606
2607         target_namelen = VNAMELEN(dentry);
2608         ASSERT(!VN_ISDIR(src_vp));
2609
2610         sip = xfs_vtoi(src_vp);
2611         tdp = XFS_BHVTOI(target_dir_bdp);
2612         mp = tdp->i_mount;
2613         if (XFS_FORCED_SHUTDOWN(mp))
2614                 return XFS_ERROR(EIO);
2615
2616         if (DM_EVENT_ENABLED(src_vp->v_vfsp, tdp, DM_EVENT_LINK)) {
2617                 error = XFS_SEND_NAMESP(mp, DM_EVENT_LINK,
2618                                         target_dir_vp, DM_RIGHT_NULL,
2619                                         src_vp, DM_RIGHT_NULL,
2620                                         target_name, NULL, 0, 0, 0);
2621                 if (error)
2622                         return error;
2623         }
2624
2625         /* Return through std_return after this point. */
2626
2627         error = XFS_QM_DQATTACH(mp, sip, 0);
2628         if (!error && sip != tdp)
2629                 error = XFS_QM_DQATTACH(mp, tdp, 0);
2630         if (error)
2631                 goto std_return;
2632
2633         tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
2634         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2635         resblks = XFS_LINK_SPACE_RES(mp, target_namelen);
2636         error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
2637                         XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2638         if (error == ENOSPC) {
2639                 resblks = 0;
2640                 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
2641                                 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2642         }
2643         if (error) {
2644                 cancel_flags = 0;
2645                 goto error_return;
2646         }
2647
2648         if (sip->i_ino < tdp->i_ino) {
2649                 ips[0] = sip;
2650                 ips[1] = tdp;
2651         } else {
2652                 ips[0] = tdp;
2653                 ips[1] = sip;
2654         }
2655
2656         xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2657
2658         /*
2659          * Increment vnode ref counts since xfs_trans_commit &
2660          * xfs_trans_cancel will both unlock the inodes and
2661          * decrement the associated ref counts.
2662          */
2663         VN_HOLD(src_vp);
2664         VN_HOLD(target_dir_vp);
2665         xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
2666         xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
2667
2668         /*
2669          * If the source has too many links, we can't make any more to it.
2670          */
2671         if (sip->i_d.di_nlink >= XFS_MAXLINK) {
2672                 error = XFS_ERROR(EMLINK);
2673                 goto error_return;
2674         }
2675
2676         /*
2677          * If we are using project inheritance, we only allow hard link
2678          * creation in our tree when the project IDs are the same; else
2679          * the tree quota mechanism could be circumvented.
2680          */
2681         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
2682                      (tdp->i_d.di_projid != sip->i_d.di_projid))) {
2683                 error = XFS_ERROR(EXDEV);
2684                 goto error_return;
2685         }
2686
2687         if (resblks == 0 &&
2688             (error = xfs_dir_canenter(tp, tdp, target_name, target_namelen)))
2689                 goto error_return;
2690
2691         XFS_BMAP_INIT(&free_list, &first_block);
2692
2693         error = xfs_dir_createname(tp, tdp, target_name, target_namelen,
2694                                    sip->i_ino, &first_block, &free_list,
2695                                    resblks);
2696         if (error)
2697                 goto abort_return;
2698         xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2699         tdp->i_gen++;
2700         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
2701
2702         error = xfs_bumplink(tp, sip);
2703         if (error)
2704                 goto abort_return;
2705
2706         /*
2707          * If this is a synchronous mount, make sure that the
2708          * link transaction goes to disk before returning to
2709          * the user.
2710          */
2711         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2712                 xfs_trans_set_sync(tp);
2713         }
2714
2715         error = xfs_bmap_finish (&tp, &free_list, &committed);
2716         if (error) {
2717                 xfs_bmap_cancel(&free_list);
2718                 goto abort_return;
2719         }
2720
2721         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2722         if (error)
2723                 goto std_return;
2724
2725         /* Fall through to std_return with error = 0. */
2726 std_return:
2727         if (DM_EVENT_ENABLED(src_vp->v_vfsp, sip,
2728                                                 DM_EVENT_POSTLINK)) {
2729                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTLINK,
2730                                 target_dir_vp, DM_RIGHT_NULL,
2731                                 src_vp, DM_RIGHT_NULL,
2732                                 target_name, NULL, 0, error, 0);
2733         }
2734         return error;
2735
2736  abort_return:
2737         cancel_flags |= XFS_TRANS_ABORT;
2738         /* FALLTHROUGH */
2739
2740  error_return:
2741         xfs_trans_cancel(tp, cancel_flags);
2742         goto std_return;
2743 }
2744
2745
2746 /*
2747  * xfs_mkdir
2748  *
2749  */
2750 STATIC int
2751 xfs_mkdir(
2752         bhv_desc_t              *dir_bdp,
2753         bhv_vname_t             *dentry,
2754         bhv_vattr_t             *vap,
2755         bhv_vnode_t             **vpp,
2756         cred_t                  *credp)
2757 {
2758         char                    *dir_name = VNAME(dentry);
2759         xfs_inode_t             *dp;
2760         xfs_inode_t             *cdp;   /* inode of created dir */
2761         bhv_vnode_t             *cvp;   /* vnode of created dir */
2762         xfs_trans_t             *tp;
2763         xfs_mount_t             *mp;
2764         int                     cancel_flags;
2765         int                     error;
2766         int                     committed;
2767         xfs_bmap_free_t         free_list;
2768         xfs_fsblock_t           first_block;
2769         bhv_vnode_t             *dir_vp;
2770         boolean_t               dp_joined_to_trans;
2771         boolean_t               created = B_FALSE;
2772         int                     dm_event_sent = 0;
2773         xfs_prid_t              prid;
2774         struct xfs_dquot        *udqp, *gdqp;
2775         uint                    resblks;
2776         int                     dm_di_mode;
2777         int                     dir_namelen;
2778
2779         dir_vp = BHV_TO_VNODE(dir_bdp);
2780         dp = XFS_BHVTOI(dir_bdp);
2781         mp = dp->i_mount;
2782
2783         if (XFS_FORCED_SHUTDOWN(mp))
2784                 return XFS_ERROR(EIO);
2785
2786         dir_namelen = VNAMELEN(dentry);
2787
2788         tp = NULL;
2789         dp_joined_to_trans = B_FALSE;
2790         dm_di_mode = vap->va_mode;
2791
2792         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
2793                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
2794                                         dir_vp, DM_RIGHT_NULL, NULL,
2795                                         DM_RIGHT_NULL, dir_name, NULL,
2796                                         dm_di_mode, 0, 0);
2797                 if (error)
2798                         return error;
2799                 dm_event_sent = 1;
2800         }
2801
2802         /* Return through std_return after this point. */
2803
2804         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2805
2806         mp = dp->i_mount;
2807         udqp = gdqp = NULL;
2808         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
2809                 prid = dp->i_d.di_projid;
2810         else if (vap->va_mask & XFS_AT_PROJID)
2811                 prid = (xfs_prid_t)vap->va_projid;
2812         else
2813                 prid = (xfs_prid_t)dfltprid;
2814
2815         /*
2816          * Make sure that we have allocated dquot(s) on disk.
2817          */
2818         error = XFS_QM_DQVOPALLOC(mp, dp,
2819                         current_fsuid(credp), current_fsgid(credp), prid,
2820                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
2821         if (error)
2822                 goto std_return;
2823
2824         tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
2825         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2826         resblks = XFS_MKDIR_SPACE_RES(mp, dir_namelen);
2827         error = xfs_trans_reserve(tp, resblks, XFS_MKDIR_LOG_RES(mp), 0,
2828                                   XFS_TRANS_PERM_LOG_RES, XFS_MKDIR_LOG_COUNT);
2829         if (error == ENOSPC) {
2830                 resblks = 0;
2831                 error = xfs_trans_reserve(tp, 0, XFS_MKDIR_LOG_RES(mp), 0,
2832                                           XFS_TRANS_PERM_LOG_RES,
2833                                           XFS_MKDIR_LOG_COUNT);
2834         }
2835         if (error) {
2836                 cancel_flags = 0;
2837                 dp = NULL;
2838                 goto error_return;
2839         }
2840
2841         xfs_ilock(dp, XFS_ILOCK_EXCL);
2842
2843         /*
2844          * Check for directory link count overflow.
2845          */
2846         if (dp->i_d.di_nlink >= XFS_MAXLINK) {
2847                 error = XFS_ERROR(EMLINK);
2848                 goto error_return;
2849         }
2850
2851         /*
2852          * Reserve disk quota and the inode.
2853          */
2854         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
2855         if (error)
2856                 goto error_return;
2857
2858         if (resblks == 0 &&
2859             (error = xfs_dir_canenter(tp, dp, dir_name, dir_namelen)))
2860                 goto error_return;
2861         /*
2862          * create the directory inode.
2863          */
2864         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 2,
2865                         0, credp, prid, resblks > 0,
2866                 &cdp, NULL);
2867         if (error) {
2868                 if (error == ENOSPC)
2869                         goto error_return;
2870                 goto abort_return;
2871         }
2872         ITRACE(cdp);
2873
2874         /*
2875          * Now we add the directory inode to the transaction.
2876          * We waited until now since xfs_dir_ialloc might start
2877          * a new transaction.  Had we joined the transaction
2878          * earlier, the locks might have gotten released.
2879          */
2880         VN_HOLD(dir_vp);
2881         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2882         dp_joined_to_trans = B_TRUE;
2883
2884         XFS_BMAP_INIT(&free_list, &first_block);
2885
2886         error = xfs_dir_createname(tp, dp, dir_name, dir_namelen, cdp->i_ino,
2887                                    &first_block, &free_list, resblks ?
2888                                    resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
2889         if (error) {
2890                 ASSERT(error != ENOSPC);
2891                 goto error1;
2892         }
2893         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2894
2895         /*
2896          * Bump the in memory version number of the parent directory
2897          * so that other processes accessing it will recognize that
2898          * the directory has changed.
2899          */
2900         dp->i_gen++;
2901
2902         error = xfs_dir_init(tp, cdp, dp);
2903         if (error)
2904                 goto error2;
2905
2906         cdp->i_gen = 1;
2907         error = xfs_bumplink(tp, dp);
2908         if (error)
2909                 goto error2;
2910
2911         cvp = XFS_ITOV(cdp);
2912
2913         created = B_TRUE;
2914
2915         *vpp = cvp;
2916         IHOLD(cdp);
2917
2918         /*
2919          * Attach the dquots to the new inode and modify the icount incore.
2920          */
2921         XFS_QM_DQVOPCREATE(mp, tp, cdp, udqp, gdqp);
2922
2923         /*
2924          * If this is a synchronous mount, make sure that the
2925          * mkdir transaction goes to disk before returning to
2926          * the user.
2927          */
2928         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2929                 xfs_trans_set_sync(tp);
2930         }
2931
2932         error = xfs_bmap_finish(&tp, &free_list, &committed);
2933         if (error) {
2934                 IRELE(cdp);
2935                 goto error2;
2936         }
2937
2938         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2939         XFS_QM_DQRELE(mp, udqp);
2940         XFS_QM_DQRELE(mp, gdqp);
2941         if (error) {
2942                 IRELE(cdp);
2943         }
2944
2945         /* Fall through to std_return with error = 0 or errno from
2946          * xfs_trans_commit. */
2947
2948 std_return:
2949         if ( (created || (error != 0 && dm_event_sent != 0)) &&
2950                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2951                                                 DM_EVENT_POSTCREATE)) {
2952                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2953                                         dir_vp, DM_RIGHT_NULL,
2954                                         created ? XFS_ITOV(cdp):NULL,
2955                                         DM_RIGHT_NULL,
2956                                         dir_name, NULL,
2957                                         dm_di_mode, error, 0);
2958         }
2959         return error;
2960
2961  error2:
2962  error1:
2963         xfs_bmap_cancel(&free_list);
2964  abort_return:
2965         cancel_flags |= XFS_TRANS_ABORT;
2966  error_return:
2967         xfs_trans_cancel(tp, cancel_flags);
2968         XFS_QM_DQRELE(mp, udqp);
2969         XFS_QM_DQRELE(mp, gdqp);
2970
2971         if (!dp_joined_to_trans && (dp != NULL)) {
2972                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2973         }
2974
2975         goto std_return;
2976 }
2977
2978
2979 /*
2980  * xfs_rmdir
2981  *
2982  */
2983 STATIC int
2984 xfs_rmdir(
2985         bhv_desc_t              *dir_bdp,
2986         bhv_vname_t             *dentry,
2987         cred_t                  *credp)
2988 {
2989         char                    *name = VNAME(dentry);
2990         xfs_inode_t             *dp;
2991         xfs_inode_t             *cdp;   /* child directory */
2992         xfs_trans_t             *tp;
2993         xfs_mount_t             *mp;
2994         int                     error;
2995         xfs_bmap_free_t         free_list;
2996         xfs_fsblock_t           first_block;
2997         int                     cancel_flags;
2998         int                     committed;
2999         bhv_vnode_t             *dir_vp;
3000         int                     dm_di_mode = S_IFDIR;
3001         int                     last_cdp_link;
3002         int                     namelen;
3003         uint                    resblks;
3004
3005         dir_vp = BHV_TO_VNODE(dir_bdp);
3006         dp = XFS_BHVTOI(dir_bdp);
3007         mp = dp->i_mount;
3008
3009         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
3010
3011         if (XFS_FORCED_SHUTDOWN(XFS_BHVTOI(dir_bdp)->i_mount))
3012                 return XFS_ERROR(EIO);
3013         namelen = VNAMELEN(dentry);
3014
3015         if (!xfs_get_dir_entry(dentry, &cdp)) {
3016                 dm_di_mode = cdp->i_d.di_mode;
3017                 IRELE(cdp);
3018         }
3019
3020         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
3021                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE,
3022                                         dir_vp, DM_RIGHT_NULL,
3023                                         NULL, DM_RIGHT_NULL,
3024                                         name, NULL, dm_di_mode, 0, 0);
3025                 if (error)
3026                         return XFS_ERROR(error);
3027         }
3028
3029         /* Return through std_return after this point. */
3030
3031         cdp = NULL;
3032
3033         /*
3034          * We need to get a reference to cdp before we get our log
3035          * reservation.  The reason for this is that we cannot call
3036          * xfs_iget for an inode for which we do not have a reference
3037          * once we've acquired a log reservation.  This is because the
3038          * inode we are trying to get might be in xfs_inactive going
3039          * for a log reservation.  Since we'll have to wait for the
3040          * inactive code to complete before returning from xfs_iget,
3041          * we need to make sure that we don't have log space reserved
3042          * when we call xfs_iget.  Instead we get an unlocked reference
3043          * to the inode before getting our log reservation.
3044          */
3045         error = xfs_get_dir_entry(dentry, &cdp);
3046         if (error) {
3047                 REMOVE_DEBUG_TRACE(__LINE__);
3048                 goto std_return;
3049         }
3050         mp = dp->i_mount;
3051         dm_di_mode = cdp->i_d.di_mode;
3052
3053         /*
3054          * Get the dquots for the inodes.
3055          */
3056         error = XFS_QM_DQATTACH(mp, dp, 0);
3057         if (!error && dp != cdp)
3058                 error = XFS_QM_DQATTACH(mp, cdp, 0);
3059         if (error) {
3060                 IRELE(cdp);
3061                 REMOVE_DEBUG_TRACE(__LINE__);
3062                 goto std_return;
3063         }
3064
3065         tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
3066         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
3067         /*
3068          * We try to get the real space reservation first,
3069          * allowing for directory btree deletion(s) implying
3070          * possible bmap insert(s).  If we can't get the space
3071          * reservation then we use 0 instead, and avoid the bmap
3072          * btree insert(s) in the directory code by, if the bmap
3073          * insert tries to happen, instead trimming the LAST
3074          * block from the directory.
3075          */
3076         resblks = XFS_REMOVE_SPACE_RES(mp);
3077         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
3078                         XFS_TRANS_PERM_LOG_RES, XFS_DEFAULT_LOG_COUNT);
3079         if (error == ENOSPC) {
3080                 resblks = 0;
3081                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
3082                                 XFS_TRANS_PERM_LOG_RES, XFS_DEFAULT_LOG_COUNT);
3083         }
3084         if (error) {
3085                 ASSERT(error != ENOSPC);
3086                 cancel_flags = 0;
3087                 IRELE(cdp);
3088                 goto error_return;
3089         }
3090         XFS_BMAP_INIT(&free_list, &first_block);
3091
3092         /*
3093          * Now lock the child directory inode and the parent directory
3094          * inode in the proper order.  This will take care of validating
3095          * that the directory entry for the child directory inode has
3096          * not changed while we were obtaining a log reservation.
3097          */
3098         error = xfs_lock_dir_and_entry(dp, dentry, cdp);
3099         if (error) {
3100                 xfs_trans_cancel(tp, cancel_flags);
3101                 IRELE(cdp);
3102                 goto std_return;
3103         }
3104
3105         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
3106         if (dp != cdp) {
3107                 /*
3108                  * Only increment the parent directory vnode count if
3109                  * we didn't bump it in looking up cdp.  The only time
3110                  * we don't bump it is when we're looking up ".".
3111                  */
3112                 VN_HOLD(dir_vp);
3113         }
3114
3115         ITRACE(cdp);
3116         xfs_trans_ijoin(tp, cdp, XFS_ILOCK_EXCL);
3117
3118         ASSERT(cdp->i_d.di_nlink >= 2);
3119         if (cdp->i_d.di_nlink != 2) {
3120                 error = XFS_ERROR(ENOTEMPTY);
3121                 goto error_return;
3122         }
3123         if (!xfs_dir_isempty(cdp)) {
3124                 error = XFS_ERROR(ENOTEMPTY);
3125                 goto error_return;
3126         }
3127
3128         error = xfs_dir_removename(tp, dp, name, namelen, cdp->i_ino,
3129                                         &first_block, &free_list, resblks);
3130         if (error)
3131                 goto error1;
3132
3133         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3134
3135         /*
3136          * Bump the in memory generation count on the parent
3137          * directory so that other can know that it has changed.
3138          */
3139         dp->i_gen++;
3140
3141         /*
3142          * Drop the link from cdp's "..".
3143          */
3144         error = xfs_droplink(tp, dp);
3145         if (error) {
3146                 goto error1;
3147         }
3148
3149         /*
3150          * Drop the link from dp to cdp.
3151          */
3152         error = xfs_droplink(tp, cdp);
3153         if (error) {
3154                 goto error1;
3155         }
3156
3157         /*
3158          * Drop the "." link from cdp to self.
3159          */
3160         error = xfs_droplink(tp, cdp);
3161         if (error) {
3162                 goto error1;
3163         }
3164
3165         /* Determine these before committing transaction */
3166         last_cdp_link = (cdp)->i_d.di_nlink==0;
3167
3168         /*
3169          * Take an extra ref on the child vnode so that it
3170          * does not go to xfs_inactive() from within the commit.
3171          */
3172         IHOLD(cdp);
3173
3174         /*
3175          * If this is a synchronous mount, make sure that the
3176          * rmdir transaction goes to disk before returning to
3177          * the user.
3178          */
3179         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
3180                 xfs_trans_set_sync(tp);
3181         }
3182
3183         error = xfs_bmap_finish (&tp, &free_list, &committed);
3184         if (error) {
3185                 xfs_bmap_cancel(&free_list);
3186                 xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES |
3187                                  XFS_TRANS_ABORT));
3188                 IRELE(cdp);
3189                 goto std_return;
3190         }
3191
3192         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
3193         if (error) {
3194                 IRELE(cdp);
3195                 goto std_return;
3196         }
3197
3198
3199         /*
3200          * Let interposed file systems know about removed links.
3201          */
3202         bhv_vop_link_removed(XFS_ITOV(cdp), dir_vp, last_cdp_link);
3203
3204         IRELE(cdp);
3205
3206         /* Fall through to std_return with error = 0 or the errno
3207          * from xfs_trans_commit. */
3208  std_return:
3209         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_POSTREMOVE)) {
3210                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
3211                                         dir_vp, DM_RIGHT_NULL,
3212                                         NULL, DM_RIGHT_NULL,
3213                                         name, NULL, dm_di_mode,
3214                                         error, 0);
3215         }
3216         return error;
3217
3218  error1:
3219         xfs_bmap_cancel(&free_list);
3220         cancel_flags |= XFS_TRANS_ABORT;
3221         /* FALLTHROUGH */
3222
3223  error_return:
3224         xfs_trans_cancel(tp, cancel_flags);
3225         goto std_return;
3226 }
3227
3228
3229 /*
3230  * Read dp's entries starting at uiop->uio_offset and translate them into
3231  * bufsize bytes worth of struct dirents starting at bufbase.
3232  */
3233 STATIC int
3234 xfs_readdir(
3235         bhv_desc_t      *dir_bdp,
3236         uio_t           *uiop,
3237         cred_t          *credp,
3238         int             *eofp)
3239 {
3240         xfs_inode_t     *dp;
3241         xfs_trans_t     *tp = NULL;
3242         int             error = 0;
3243         uint            lock_mode;
3244
3245         vn_trace_entry(BHV_TO_VNODE(dir_bdp), __FUNCTION__,
3246                                                (inst_t *)__return_address);
3247         dp = XFS_BHVTOI(dir_bdp);
3248
3249         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
3250                 return XFS_ERROR(EIO);
3251
3252         lock_mode = xfs_ilock_map_shared(dp);
3253         error = xfs_dir_getdents(tp, dp, uiop, eofp);
3254         xfs_iunlock_map_shared(dp, lock_mode);
3255         return error;
3256 }
3257
3258
3259 STATIC int
3260 xfs_symlink(
3261         bhv_desc_t              *dir_bdp,
3262         bhv_vname_t             *dentry,
3263         bhv_vattr_t             *vap,
3264         char                    *target_path,
3265         bhv_vnode_t             **vpp,
3266         cred_t                  *credp)
3267 {
3268         xfs_trans_t             *tp;
3269         xfs_mount_t             *mp;
3270         xfs_inode_t             *dp;
3271         xfs_inode_t             *ip;
3272         int                     error;
3273         int                     pathlen;
3274         xfs_bmap_free_t         free_list;
3275         xfs_fsblock_t           first_block;
3276         boolean_t               dp_joined_to_trans;
3277         bhv_vnode_t             *dir_vp;
3278         uint                    cancel_flags;
3279         int                     committed;
3280         xfs_fileoff_t           first_fsb;
3281         xfs_filblks_t           fs_blocks;
3282         int                     nmaps;
3283         xfs_bmbt_irec_t         mval[SYMLINK_MAPS];
3284         xfs_daddr_t             d;
3285         char                    *cur_chunk;
3286         int                     byte_cnt;
3287         int                     n;
3288         xfs_buf_t               *bp;
3289         xfs_prid_t              prid;
3290         struct xfs_dquot        *udqp, *gdqp;
3291         uint                    resblks;
3292         char                    *link_name = VNAME(dentry);
3293         int                     link_namelen;
3294
3295         *vpp = NULL;
3296         dir_vp = BHV_TO_VNODE(dir_bdp);
3297         dp = XFS_BHVTOI(dir_bdp);
3298         dp_joined_to_trans = B_FALSE;
3299         error = 0;
3300         ip = NULL;
3301         tp = NULL;
3302
3303         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
3304
3305         mp = dp->i_mount;
3306
3307         if (XFS_FORCED_SHUTDOWN(mp))
3308                 return XFS_ERROR(EIO);
3309
3310         link_namelen = VNAMELEN(dentry);
3311
3312         /*
3313          * Check component lengths of the target path name.
3314          */
3315         pathlen = strlen(target_path);
3316         if (pathlen >= MAXPATHLEN)      /* total string too long */
3317                 return XFS_ERROR(ENAMETOOLONG);
3318         if (pathlen >= MAXNAMELEN) {    /* is any component too long? */
3319                 int len, total;
3320                 char *path;
3321
3322                 for (total = 0, path = target_path; total < pathlen;) {
3323                         /*
3324                          * Skip any slashes.
3325                          */
3326                         while(*path == '/') {
3327                                 total++;
3328                                 path++;
3329                         }
3330
3331                         /*
3332                          * Count up to the next slash or end of path.
3333                          * Error out if the component is bigger than MAXNAMELEN.
3334                          */
3335                         for(len = 0; *path != '/' && total < pathlen;total++, path++) {
3336                                 if (++len >= MAXNAMELEN) {
3337                                         error = ENAMETOOLONG;
3338                                         return error;
3339                                 }
3340                         }
3341                 }
3342         }
3343
3344         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_SYMLINK)) {
3345                 error = XFS_SEND_NAMESP(mp, DM_EVENT_SYMLINK, dir_vp,
3346                                         DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
3347                                         link_name, target_path, 0, 0, 0);
3348                 if (error)
3349                         return error;
3350         }
3351
3352         /* Return through std_return after this point. */
3353
3354         udqp = gdqp = NULL;
3355         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
3356                 prid = dp->i_d.di_projid;
3357         else if (vap->va_mask & XFS_AT_PROJID)
3358                 prid = (xfs_prid_t)vap->va_projid;
3359         else
3360                 prid = (xfs_prid_t)dfltprid;
3361
3362         /*
3363          * Make sure that we have allocated dquot(s) on disk.
3364          */
3365         error = XFS_QM_DQVOPALLOC(mp, dp,
3366                         current_fsuid(credp), current_fsgid(credp), prid,
3367                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
3368         if (error)
3369                 goto std_return;
3370
3371         tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
3372         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
3373         /*
3374          * The symlink will fit into the inode data fork?
3375          * There can't be any attributes so we get the whole variable part.
3376          */
3377         if (pathlen <= XFS_LITINO(mp))
3378                 fs_blocks = 0;
3379         else
3380                 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
3381         resblks = XFS_SYMLINK_SPACE_RES(mp, link_namelen, fs_blocks);
3382         error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
3383                         XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
3384         if (error == ENOSPC && fs_blocks == 0) {
3385                 resblks = 0;
3386                 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
3387                                 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
3388         }
3389         if (error) {
3390                 cancel_flags = 0;
3391                 dp = NULL;
3392                 goto error_return;
3393         }
3394
3395         xfs_ilock(dp, XFS_ILOCK_EXCL);
3396
3397         /*
3398          * Check whether the directory allows new symlinks or not.
3399          */
3400         if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
3401                 error = XFS_ERROR(EPERM);
3402                 goto error_return;
3403         }
3404
3405         /*
3406          * Reserve disk quota : blocks and inode.
3407          */
3408         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
3409         if (error)
3410                 goto error_return;
3411
3412         /*
3413          * Check for ability to enter directory entry, if no space reserved.
3414          */
3415         if (resblks == 0 &&
3416             (error = xfs_dir_canenter(tp, dp, link_name, link_namelen)))
3417                 goto error_return;
3418         /*
3419          * Initialize the bmap freelist prior to calling either
3420          * bmapi or the directory create code.
3421          */
3422         XFS_BMAP_INIT(&free_list, &first_block);
3423
3424         /*
3425          * Allocate an inode for the symlink.
3426          */
3427         error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (vap->va_mode&~S_IFMT),
3428                                1, 0, credp, prid, resblks > 0, &ip, NULL);
3429         if (error) {
3430                 if (error == ENOSPC)
3431                         goto error_return;
3432                 goto error1;
3433         }
3434         ITRACE(ip);
3435
3436         VN_HOLD(dir_vp);
3437         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
3438         dp_joined_to_trans = B_TRUE;
3439
3440         /*
3441          * Also attach the dquot(s) to it, if applicable.
3442          */
3443         XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
3444
3445         if (resblks)
3446                 resblks -= XFS_IALLOC_SPACE_RES(mp);
3447         /*
3448          * If the symlink will fit into the inode, write it inline.
3449          */
3450         if (pathlen <= XFS_IFORK_DSIZE(ip)) {
3451                 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
3452                 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
3453                 ip->i_d.di_size = pathlen;
3454
3455                 /*
3456                  * The inode was initially created in extent format.
3457                  */
3458                 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
3459                 ip->i_df.if_flags |= XFS_IFINLINE;
3460
3461                 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
3462                 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
3463
3464         } else {
3465                 first_fsb = 0;
3466                 nmaps = SYMLINK_MAPS;
3467
3468                 error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
3469                                   XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
3470                                   &first_block, resblks, mval, &nmaps,
3471                                   &free_list, NULL);
3472                 if (error) {
3473                         goto error1;
3474                 }
3475
3476                 if (resblks)
3477                         resblks -= fs_blocks;
3478                 ip->i_d.di_size = pathlen;
3479                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3480
3481                 cur_chunk = target_path;
3482                 for (n = 0; n < nmaps; n++) {
3483                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
3484                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
3485                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
3486                                                BTOBB(byte_cnt), 0);
3487                         ASSERT(bp && !XFS_BUF_GETERROR(bp));
3488                         if (pathlen < byte_cnt) {
3489                                 byte_cnt = pathlen;
3490                         }
3491                         pathlen -= byte_cnt;
3492
3493                         memcpy(XFS_BUF_PTR(bp), cur_chunk, byte_cnt);
3494                         cur_chunk += byte_cnt;
3495
3496                         xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
3497                 }
3498         }
3499
3500         /*
3501          * Create the directory entry for the symlink.
3502          */
3503         error = xfs_dir_createname(tp, dp, link_name, link_namelen, ip->i_ino,
3504                                    &first_block, &free_list, resblks);
3505         if (error)
3506                 goto error1;
3507         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3508         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
3509
3510         /*
3511          * Bump the in memory version number of the parent directory
3512          * so that other processes accessing it will recognize that
3513          * the directory has changed.
3514          */
3515         dp->i_gen++;
3516
3517         /*
3518          * If this is a synchronous mount, make sure that the
3519          * symlink transaction goes to disk before returning to
3520          * the user.
3521          */
3522         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
3523                 xfs_trans_set_sync(tp);
3524         }
3525
3526         /*
3527          * xfs_trans_commit normally decrements the vnode ref count
3528          * when it unlocks the inode. Since we want to return the
3529          * vnode to the caller, we bump the vnode ref count now.
3530          */
3531         IHOLD(ip);
3532
3533         error = xfs_bmap_finish(&tp, &free_list, &committed);
3534         if (error) {
3535                 goto error2;
3536         }
3537         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
3538         XFS_QM_DQRELE(mp, udqp);
3539         XFS_QM_DQRELE(mp, gdqp);
3540
3541         /* Fall through to std_return with error = 0 or errno from
3542          * xfs_trans_commit     */
3543 std_return:
3544         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
3545                              DM_EVENT_POSTSYMLINK)) {
3546                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTSYMLINK,
3547                                         dir_vp, DM_RIGHT_NULL,
3548                                         error ? NULL : XFS_ITOV(ip),
3549                                         DM_RIGHT_NULL, link_name, target_path,
3550                                         0, error, 0);
3551         }
3552
3553         if (!error) {
3554                 bhv_vnode_t *vp;
3555
3556                 ASSERT(ip);
3557                 vp = XFS_ITOV(ip);
3558                 *vpp = vp;
3559         }
3560         return error;
3561
3562  error2:
3563         IRELE(ip);
3564  error1:
3565         xfs_bmap_cancel(&free_list);
3566         cancel_flags |= XFS_TRANS_ABORT;
3567  error_return:
3568         xfs_trans_cancel(tp, cancel_flags);
3569         XFS_QM_DQRELE(mp, udqp);
3570         XFS_QM_DQRELE(mp, gdqp);
3571
3572         if (!dp_joined_to_trans && (dp != NULL)) {
3573                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
3574         }
3575
3576         goto std_return;
3577 }
3578
3579
3580 /*
3581  * xfs_fid2
3582  *
3583  * A fid routine that takes a pointer to a previously allocated
3584  * fid structure (like xfs_fast_fid) but uses a 64 bit inode number.
3585  */
3586 STATIC int
3587 xfs_fid2(
3588         bhv_desc_t      *bdp,
3589         fid_t           *fidp)
3590 {
3591         xfs_inode_t     *ip;
3592         xfs_fid2_t      *xfid;
3593
3594         vn_trace_entry(BHV_TO_VNODE(bdp), __FUNCTION__,
3595                                        (inst_t *)__return_address);
3596         ASSERT(sizeof(fid_t) >= sizeof(xfs_fid2_t));
3597
3598         xfid = (xfs_fid2_t *)fidp;
3599         ip = XFS_BHVTOI(bdp);
3600         xfid->fid_len = sizeof(xfs_fid2_t) - sizeof(xfid->fid_len);
3601         xfid->fid_pad = 0;
3602         /*
3603          * use memcpy because the inode is a long long and there's no
3604          * assurance that xfid->fid_ino is properly aligned.
3605          */
3606         memcpy(&xfid->fid_ino, &ip->i_ino, sizeof(xfid->fid_ino));
3607         xfid->fid_gen = ip->i_d.di_gen;
3608
3609         return 0;
3610 }
3611
3612
3613 /*
3614  * xfs_rwlock
3615  */
3616 int
3617 xfs_rwlock(
3618         bhv_desc_t      *bdp,
3619         bhv_vrwlock_t   locktype)
3620 {
3621         xfs_inode_t     *ip;
3622         bhv_vnode_t     *vp;
3623
3624         vp = BHV_TO_VNODE(bdp);
3625         if (VN_ISDIR(vp))
3626                 return 1;
3627         ip = XFS_BHVTOI(bdp);
3628         if (locktype == VRWLOCK_WRITE) {
3629                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
3630         } else if (locktype == VRWLOCK_TRY_READ) {
3631                 return xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED);
3632         } else if (locktype == VRWLOCK_TRY_WRITE) {
3633                 return xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL);
3634         } else {
3635                 ASSERT((locktype == VRWLOCK_READ) ||
3636                        (locktype == VRWLOCK_WRITE_DIRECT));
3637                 xfs_ilock(ip, XFS_IOLOCK_SHARED);
3638         }
3639
3640         return 1;
3641 }
3642
3643
3644 /*
3645  * xfs_rwunlock
3646  */
3647 void
3648 xfs_rwunlock(
3649         bhv_desc_t      *bdp,
3650         bhv_vrwlock_t   locktype)
3651 {
3652         xfs_inode_t     *ip;
3653         bhv_vnode_t     *vp;
3654
3655         vp = BHV_TO_VNODE(bdp);
3656         if (VN_ISDIR(vp))
3657                 return;
3658         ip = XFS_BHVTOI(bdp);
3659         if (locktype == VRWLOCK_WRITE) {
3660                 /*
3661                  * In the write case, we may have added a new entry to
3662                  * the reference cache.  This might store a pointer to
3663                  * an inode to be released in this inode.  If it is there,
3664                  * clear the pointer and release the inode after unlocking
3665                  * this one.
3666                  */
3667                 xfs_refcache_iunlock(ip, XFS_IOLOCK_EXCL);
3668         } else {
3669                 ASSERT((locktype == VRWLOCK_READ) ||
3670                        (locktype == VRWLOCK_WRITE_DIRECT));
3671                 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
3672         }
3673         return;
3674 }
3675
3676 STATIC int
3677 xfs_inode_flush(
3678         bhv_desc_t      *bdp,
3679         int             flags)
3680 {
3681         xfs_inode_t     *ip;
3682         xfs_mount_t     *mp;
3683         xfs_inode_log_item_t *iip;
3684         int             error = 0;
3685
3686         ip = XFS_BHVTOI(bdp);
3687         mp = ip->i_mount;
3688         iip = ip->i_itemp;
3689
3690         if (XFS_FORCED_SHUTDOWN(mp))
3691                 return XFS_ERROR(EIO);
3692
3693         /*
3694          * Bypass inodes which have already been cleaned by
3695          * the inode flush clustering code inside xfs_iflush
3696          */
3697         if ((ip->i_update_core == 0) &&
3698             ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL)))
3699                 return 0;
3700
3701         if (flags & FLUSH_LOG) {
3702                 if (iip && iip->ili_last_lsn) {
3703                         xlog_t          *log = mp->m_log;
3704                         xfs_lsn_t       sync_lsn;
3705                         int             s, log_flags = XFS_LOG_FORCE;
3706
3707                         s = GRANT_LOCK(log);
3708                         sync_lsn = log->l_last_sync_lsn;
3709                         GRANT_UNLOCK(log, s);
3710
3711                         if ((XFS_LSN_CMP(iip->ili_last_lsn, sync_lsn) <= 0))
3712                                 return 0;
3713
3714                         if (flags & FLUSH_SYNC)
3715                                 log_flags |= XFS_LOG_SYNC;
3716                         return xfs_log_force(mp, iip->ili_last_lsn, log_flags);
3717                 }
3718         }
3719
3720         /*
3721          * We make this non-blocking if the inode is contended,
3722          * return EAGAIN to indicate to the caller that they
3723          * did not succeed. This prevents the flush path from
3724          * blocking on inodes inside another operation right
3725          * now, they get caught later by xfs_sync.
3726          */
3727         if (flags & FLUSH_INODE) {
3728                 int     flush_flags;
3729
3730                 if (xfs_ipincount(ip))
3731                         return EAGAIN;
3732
3733                 if (flags & FLUSH_SYNC) {
3734                         xfs_ilock(ip, XFS_ILOCK_SHARED);
3735                         xfs_iflock(ip);
3736                 } else if (xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
3737                         if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip)) {
3738                                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
3739                                 return EAGAIN;
3740                         }
3741                 } else {
3742                         return EAGAIN;
3743                 }
3744
3745                 if (flags & FLUSH_SYNC)
3746                         flush_flags = XFS_IFLUSH_SYNC;
3747                 else
3748                         flush_flags = XFS_IFLUSH_ASYNC;
3749
3750                 error = xfs_iflush(ip, flush_flags);
3751                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
3752         }
3753
3754         return error;
3755 }
3756
3757 int
3758 xfs_set_dmattrs (
3759         bhv_desc_t      *bdp,
3760         u_int           evmask,
3761         u_int16_t       state,
3762         cred_t          *credp)
3763 {
3764         xfs_inode_t     *ip;
3765         xfs_trans_t     *tp;
3766         xfs_mount_t     *mp;
3767         int             error;
3768
3769         if (!capable(CAP_SYS_ADMIN))
3770                 return XFS_ERROR(EPERM);
3771
3772         ip = XFS_BHVTOI(bdp);
3773         mp = ip->i_mount;
3774
3775         if (XFS_FORCED_SHUTDOWN(mp))
3776                 return XFS_ERROR(EIO);
3777
3778         tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
3779         error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
3780         if (error) {
3781                 xfs_trans_cancel(tp, 0);
3782                 return error;
3783         }
3784         xfs_ilock(ip, XFS_ILOCK_EXCL);
3785         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3786
3787         ip->i_iocore.io_dmevmask = ip->i_d.di_dmevmask = evmask;
3788         ip->i_iocore.io_dmstate  = ip->i_d.di_dmstate  = state;
3789
3790         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3791         IHOLD(ip);
3792         error = xfs_trans_commit(tp, 0);
3793
3794         return error;
3795 }
3796
3797 STATIC int
3798 xfs_reclaim(
3799         bhv_desc_t      *bdp)
3800 {
3801         xfs_inode_t     *ip;
3802         bhv_vnode_t     *vp;
3803
3804         vp = BHV_TO_VNODE(bdp);
3805         ip = XFS_BHVTOI(bdp);
3806
3807         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
3808
3809         ASSERT(!VN_MAPPED(vp));
3810
3811         /* bad inode, get out here ASAP */
3812         if (VN_BAD(vp)) {
3813                 xfs_ireclaim(ip);
3814                 return 0;
3815         }
3816
3817         vn_iowait(vp);
3818
3819         ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
3820
3821         /*
3822          * Make sure the atime in the XFS inode is correct before freeing the
3823          * Linux inode.
3824          */
3825         xfs_synchronize_atime(ip);
3826
3827         /*
3828          * If we have nothing to flush with this inode then complete the
3829          * teardown now, otherwise break the link between the xfs inode and the
3830          * linux inode and clean up the xfs inode later. This avoids flushing
3831          * the inode to disk during the delete operation itself.
3832          *
3833          * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
3834          * first to ensure that xfs_iunpin() will never see an xfs inode
3835          * that has a linux inode being reclaimed. Synchronisation is provided
3836          * by the i_flags_lock.
3837          */
3838         if (!ip->i_update_core && (ip->i_itemp == NULL)) {
3839                 xfs_ilock(ip, XFS_ILOCK_EXCL);
3840                 xfs_iflock(ip);
3841                 return xfs_finish_reclaim(ip, 1, XFS_IFLUSH_DELWRI_ELSE_SYNC);
3842         } else {
3843                 xfs_mount_t     *mp = ip->i_mount;
3844
3845                 /* Protect sync and unpin from us */
3846                 XFS_MOUNT_ILOCK(mp);
3847                 spin_lock(&ip->i_flags_lock);
3848                 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
3849                 vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
3850                 spin_unlock(&ip->i_flags_lock);
3851                 list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
3852                 XFS_MOUNT_IUNLOCK(mp);
3853         }
3854         return 0;
3855 }
3856
3857 int
3858 xfs_finish_reclaim(
3859         xfs_inode_t     *ip,
3860         int             locked,
3861         int             sync_mode)
3862 {
3863         xfs_ihash_t     *ih = ip->i_hash;
3864         bhv_vnode_t     *vp = XFS_ITOV_NULL(ip);
3865         int             error;
3866
3867         if (vp && VN_BAD(vp))
3868                 goto reclaim;
3869
3870         /* The hash lock here protects a thread in xfs_iget_core from
3871          * racing with us on linking the inode back with a vnode.
3872          * Once we have the XFS_IRECLAIM flag set it will not touch
3873          * us.
3874          */
3875         write_lock(&ih->ih_lock);
3876         spin_lock(&ip->i_flags_lock);
3877         if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
3878             (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) && vp == NULL)) {
3879                 spin_unlock(&ip->i_flags_lock);
3880                 write_unlock(&ih->ih_lock);
3881                 if (locked) {
3882                         xfs_ifunlock(ip);
3883                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
3884                 }
3885                 return 1;
3886         }
3887         __xfs_iflags_set(ip, XFS_IRECLAIM);
3888         spin_unlock(&ip->i_flags_lock);
3889         write_unlock(&ih->ih_lock);
3890
3891         /*
3892          * If the inode is still dirty, then flush it out.  If the inode
3893          * is not in the AIL, then it will be OK to flush it delwri as
3894          * long as xfs_iflush() does not keep any references to the inode.
3895          * We leave that decision up to xfs_iflush() since it has the
3896          * knowledge of whether it's OK to simply do a delwri flush of
3897          * the inode or whether we need to wait until the inode is
3898          * pulled from the AIL.
3899          * We get the flush lock regardless, though, just to make sure
3900          * we don't free it while it is being flushed.
3901          */
3902         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
3903                 if (!locked) {
3904                         xfs_ilock(ip, XFS_ILOCK_EXCL);
3905                         xfs_iflock(ip);
3906                 }
3907
3908                 if (ip->i_update_core ||
3909                     ((ip->i_itemp != NULL) &&
3910                      (ip->i_itemp->ili_format.ilf_fields != 0))) {
3911                         error = xfs_iflush(ip, sync_mode);
3912                         /*
3913                          * If we hit an error, typically because of filesystem
3914                          * shutdown, we don't need to let vn_reclaim to know
3915                          * because we're gonna reclaim the inode anyway.
3916                          */
3917                         if (error) {
3918                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3919                                 goto reclaim;
3920                         }
3921                         xfs_iflock(ip); /* synchronize with xfs_iflush_done */
3922                 }
3923
3924                 ASSERT(ip->i_update_core == 0);
3925                 ASSERT(ip->i_itemp == NULL ||
3926                        ip->i_itemp->ili_format.ilf_fields == 0);
3927                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3928         } else if (locked) {
3929                 /*
3930                  * We are not interested in doing an iflush if we're
3931                  * in the process of shutting down the filesystem forcibly.
3932                  * So, just reclaim the inode.
3933                  */
3934                 xfs_ifunlock(ip);
3935                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3936         }
3937
3938  reclaim:
3939         xfs_ireclaim(ip);
3940         return 0;
3941 }
3942
3943 int
3944 xfs_finish_reclaim_all(xfs_mount_t *mp, int noblock)
3945 {
3946         int             purged;
3947         xfs_inode_t     *ip, *n;
3948         int             done = 0;
3949
3950         while (!done) {
3951                 purged = 0;
3952                 XFS_MOUNT_ILOCK(mp);
3953                 list_for_each_entry_safe(ip, n, &mp->m_del_inodes, i_reclaim) {
3954                         if (noblock) {
3955                                 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0)
3956                                         continue;
3957                                 if (xfs_ipincount(ip) ||
3958                                     !xfs_iflock_nowait(ip)) {
3959                                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
3960                                         continue;
3961                                 }
3962                         }
3963                         XFS_MOUNT_IUNLOCK(mp);
3964                         if (xfs_finish_reclaim(ip, noblock,
3965                                         XFS_IFLUSH_DELWRI_ELSE_ASYNC))
3966                                 delay(1);
3967                         purged = 1;
3968                         break;
3969                 }
3970
3971                 done = !purged;
3972         }
3973
3974         XFS_MOUNT_IUNLOCK(mp);
3975         return 0;
3976 }
3977
3978 /*
3979  * xfs_alloc_file_space()
3980  *      This routine allocates disk space for the given file.
3981  *
3982  *      If alloc_type == 0, this request is for an ALLOCSP type
3983  *      request which will change the file size.  In this case, no
3984  *      DMAPI event will be generated by the call.  A TRUNCATE event
3985  *      will be generated later by xfs_setattr.
3986  *
3987  *      If alloc_type != 0, this request is for a RESVSP type
3988  *      request, and a DMAPI DM_EVENT_WRITE will be generated if the
3989  *      lower block boundary byte address is less than the file's
3990  *      length.
3991  *
3992  * RETURNS:
3993  *       0 on success
3994  *      errno on error
3995  *
3996  */
3997 STATIC int
3998 xfs_alloc_file_space(
3999         xfs_inode_t             *ip,
4000         xfs_off_t               offset,
4001         xfs_off_t               len,
4002         int                     alloc_type,
4003         int                     attr_flags)
4004 {
4005         xfs_mount_t             *mp = ip->i_mount;
4006         xfs_off_t               count;
4007         xfs_filblks_t           allocated_fsb;
4008         xfs_filblks_t           allocatesize_fsb;
4009         xfs_extlen_t            extsz, temp;
4010         xfs_fileoff_t           startoffset_fsb;
4011         xfs_fsblock_t           firstfsb;
4012         int                     nimaps;
4013         int                     bmapi_flag;
4014         int                     quota_flag;
4015         int                     rt;
4016         xfs_trans_t             *tp;
4017         xfs_bmbt_irec_t         imaps[1], *imapp;
4018         xfs_bmap_free_t         free_list;
4019         uint                    qblocks, resblks, resrtextents;
4020         int                     committed;
4021         int                     error;
4022
4023         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
4024
4025         if (XFS_FORCED_SHUTDOWN(mp))
4026                 return XFS_ERROR(EIO);
4027
4028         rt = XFS_IS_REALTIME_INODE(ip);
4029         if (unlikely(rt)) {
4030                 if (!(extsz = ip->i_d.di_extsize))
4031                         extsz = mp->m_sb.sb_rextsize;
4032         } else {
4033                 extsz = ip->i_d.di_extsize;
4034         }
4035
4036         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
4037                 return error;
4038
4039         if (len <= 0)
4040                 return XFS_ERROR(EINVAL);
4041
4042         count = len;
4043         error = 0;
4044         imapp = &imaps[0];
4045         nimaps = 1;
4046         bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
4047         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
4048         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
4049
4050         /*      Generate a DMAPI event if needed.       */
4051         if (alloc_type != 0 && offset < ip->i_d.di_size &&
4052                         (attr_flags&ATTR_DMI) == 0  &&
4053                         DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_WRITE)) {
4054                 xfs_off_t           end_dmi_offset;
4055
4056                 end_dmi_offset = offset+len;
4057                 if (end_dmi_offset > ip->i_d.di_size)
4058                         end_dmi_offset = ip->i_d.di_size;
4059                 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, XFS_ITOV(ip),
4060                         offset, end_dmi_offset - offset,
4061                         0, NULL);
4062                 if (error)
4063                         return error;
4064         }
4065
4066         /*
4067          * Allocate file space until done or until there is an error
4068          */
4069 retry:
4070         while (allocatesize_fsb && !error) {
4071                 xfs_fileoff_t   s, e;
4072
4073                 /*
4074                  * Determine space reservations for data/realtime.
4075                  */
4076                 if (unlikely(extsz)) {
4077                         s = startoffset_fsb;
4078                         do_div(s, extsz);
4079                         s *= extsz;
4080                         e = startoffset_fsb + allocatesize_fsb;
4081                         if ((temp = do_mod(startoffset_fsb, extsz)))
4082                                 e += temp;
4083                         if ((temp = do_mod(e, extsz)))
4084                                 e += extsz - temp;
4085                 } else {
4086                         s = 0;
4087                         e = allocatesize_fsb;
4088                 }
4089
4090                 if (unlikely(rt)) {
4091                         resrtextents = qblocks = (uint)(e - s);
4092                         resrtextents /= mp->m_sb.sb_rextsize;
4093                         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
4094                         quota_flag = XFS_QMOPT_RES_RTBLKS;
4095                 } else {
4096                         resrtextents = 0;
4097                         resblks = qblocks = \
4098                                 XFS_DIOSTRAT_SPACE_RES(mp, (uint)(e - s));
4099                         quota_flag = XFS_QMOPT_RES_REGBLKS;
4100                 }
4101
4102                 /*
4103                  * Allocate and setup the transaction.
4104                  */
4105                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
4106                 error = xfs_trans_reserve(tp, resblks,
4107                                           XFS_WRITE_LOG_RES(mp), resrtextents,
4108                                           XFS_TRANS_PERM_LOG_RES,
4109                                           XFS_WRITE_LOG_COUNT);
4110                 /*
4111                  * Check for running out of space
4112                  */
4113                 if (error) {
4114                         /*
4115                          * Free the transaction structure.
4116                          */
4117                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
4118                         xfs_trans_cancel(tp, 0);
4119                         break;
4120                 }
4121                 xfs_ilock(ip, XFS_ILOCK_EXCL);
4122                 error = XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip,
4123                                                       qblocks, 0, quota_flag);
4124                 if (error)
4125                         goto error1;
4126
4127                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4128                 xfs_trans_ihold(tp, ip);
4129
4130                 /*
4131                  * Issue the xfs_bmapi() call to allocate the blocks
4132                  */
4133                 XFS_BMAP_INIT(&free_list, &firstfsb);
4134                 error = XFS_BMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
4135                                   allocatesize_fsb, bmapi_flag,
4136                                   &firstfsb, 0, imapp, &nimaps,
4137                                   &free_list, NULL);
4138                 if (error) {
4139                         goto error0;
4140                 }
4141
4142                 /*
4143                  * Complete the transaction
4144                  */
4145                 error = xfs_bmap_finish(&tp, &free_list, &committed);
4146                 if (error) {
4147                         goto error0;
4148                 }
4149
4150                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
4151                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4152                 if (error) {
4153                         break;
4154                 }
4155
4156                 allocated_fsb = imapp->br_blockcount;
4157
4158                 if (nimaps == 0) {
4159                         error = XFS_ERROR(ENOSPC);
4160                         break;
4161                 }
4162
4163                 startoffset_fsb += allocated_fsb;
4164                 allocatesize_fsb -= allocated_fsb;
4165         }
4166 dmapi_enospc_check:
4167         if (error == ENOSPC && (attr_flags&ATTR_DMI) == 0 &&
4168             DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_NOSPACE)) {
4169
4170                 error = XFS_SEND_NAMESP(mp, DM_EVENT_NOSPACE,
4171                                 XFS_ITOV(ip), DM_RIGHT_NULL,
4172                                 XFS_ITOV(ip), DM_RIGHT_NULL,
4173                                 NULL, NULL, 0, 0, 0); /* Delay flag intentionally unused */
4174                 if (error == 0)
4175                         goto retry;     /* Maybe DMAPI app. has made space */
4176                 /* else fall through with error from XFS_SEND_DATA */
4177         }
4178
4179         return error;
4180
4181 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
4182         xfs_bmap_cancel(&free_list);
4183         XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp, tp, ip, qblocks, 0, quota_flag);
4184
4185 error1: /* Just cancel transaction */
4186         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
4187         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4188         goto dmapi_enospc_check;
4189 }
4190
4191 /*
4192  * Zero file bytes between startoff and endoff inclusive.
4193  * The iolock is held exclusive and no blocks are buffered.
4194  */
4195 STATIC int
4196 xfs_zero_remaining_bytes(
4197         xfs_inode_t             *ip,
4198         xfs_off_t               startoff,
4199         xfs_off_t               endoff)
4200 {
4201         xfs_bmbt_irec_t         imap;
4202         xfs_fileoff_t           offset_fsb;
4203         xfs_off_t               lastoffset;
4204         xfs_off_t               offset;
4205         xfs_buf_t               *bp;
4206         xfs_mount_t             *mp = ip->i_mount;
4207         int                     nimap;
4208         int                     error = 0;
4209
4210         bp = xfs_buf_get_noaddr(mp->m_sb.sb_blocksize,
4211                                 ip->i_d.di_flags & XFS_DIFLAG_REALTIME ?
4212                                 mp->m_rtdev_targp : mp->m_ddev_targp);
4213
4214         for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
4215                 offset_fsb = XFS_B_TO_FSBT(mp, offset);
4216                 nimap = 1;
4217                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, offset_fsb, 1, 0,
4218                         NULL, 0, &imap, &nimap, NULL, NULL);
4219                 if (error || nimap < 1)
4220                         break;
4221                 ASSERT(imap.br_blockcount >= 1);
4222                 ASSERT(imap.br_startoff == offset_fsb);
4223                 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
4224                 if (lastoffset > endoff)
4225                         lastoffset = endoff;
4226                 if (imap.br_startblock == HOLESTARTBLOCK)
4227                         continue;
4228                 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4229                 if (imap.br_state == XFS_EXT_UNWRITTEN)
4230                         continue;
4231                 XFS_BUF_UNDONE(bp);
4232                 XFS_BUF_UNWRITE(bp);
4233                 XFS_BUF_READ(bp);
4234                 XFS_BUF_SET_ADDR(bp, XFS_FSB_TO_DB(ip, imap.br_startblock));
4235                 xfsbdstrat(mp, bp);
4236                 if ((error = xfs_iowait(bp))) {
4237                         xfs_ioerror_alert("xfs_zero_remaining_bytes(read)",
4238                                           mp, bp, XFS_BUF_ADDR(bp));
4239                         break;
4240                 }
4241                 memset(XFS_BUF_PTR(bp) +
4242                         (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
4243                       0, lastoffset - offset + 1);
4244                 XFS_BUF_UNDONE(bp);
4245                 XFS_BUF_UNREAD(bp);
4246                 XFS_BUF_WRITE(bp);
4247                 xfsbdstrat(mp, bp);
4248                 if ((error = xfs_iowait(bp))) {
4249                         xfs_ioerror_alert("xfs_zero_remaining_bytes(write)",
4250                                           mp, bp, XFS_BUF_ADDR(bp));
4251                         break;
4252                 }
4253         }
4254         xfs_buf_free(bp);
4255         return error;
4256 }
4257
4258 /*
4259  * xfs_free_file_space()
4260  *      This routine frees disk space for the given file.
4261  *
4262  *      This routine is only called by xfs_change_file_space
4263  *      for an UNRESVSP type call.
4264  *
4265  * RETURNS:
4266  *       0 on success
4267  *      errno on error
4268  *
4269  */
4270 STATIC int
4271 xfs_free_file_space(
4272         xfs_inode_t             *ip,
4273         xfs_off_t               offset,
4274         xfs_off_t               len,
4275         int                     attr_flags)
4276 {
4277         bhv_vnode_t             *vp;
4278         int                     committed;
4279         int                     done;
4280         xfs_off_t               end_dmi_offset;
4281         xfs_fileoff_t           endoffset_fsb;
4282         int                     error;
4283         xfs_fsblock_t           firstfsb;
4284         xfs_bmap_free_t         free_list;
4285         xfs_off_t               ilen;
4286         xfs_bmbt_irec_t         imap;
4287         xfs_off_t               ioffset;
4288         xfs_extlen_t            mod=0;
4289         xfs_mount_t             *mp;
4290         int                     nimap;
4291         uint                    resblks;
4292         uint                    rounding;
4293         int                     rt;
4294         xfs_fileoff_t           startoffset_fsb;
4295         xfs_trans_t             *tp;
4296         int                     need_iolock = 1;
4297
4298         vp = XFS_ITOV(ip);
4299         mp = ip->i_mount;
4300
4301         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
4302
4303         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
4304                 return error;
4305
4306         error = 0;
4307         if (len <= 0)   /* if nothing being freed */
4308                 return error;
4309         rt = (ip->i_d.di_flags & XFS_DIFLAG_REALTIME);
4310         startoffset_fsb = XFS_B_TO_FSB(mp, offset);
4311         end_dmi_offset = offset + len;
4312         endoffset_fsb = XFS_B_TO_FSBT(mp, end_dmi_offset);
4313
4314         if (offset < ip->i_d.di_size &&
4315             (attr_flags & ATTR_DMI) == 0 &&
4316             DM_EVENT_ENABLED(XFS_MTOVFS(mp), ip, DM_EVENT_WRITE)) {
4317                 if (end_dmi_offset > ip->i_d.di_size)
4318                         end_dmi_offset = ip->i_d.di_size;
4319                 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, vp,
4320                                 offset, end_dmi_offset - offset,
4321                                 AT_DELAY_FLAG(attr_flags), NULL);
4322                 if (error)
4323                         return error;
4324         }
4325
4326         if (attr_flags & ATTR_NOLOCK)
4327                 need_iolock = 0;
4328         if (need_iolock) {
4329                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
4330                 vn_iowait(vp);  /* wait for the completion of any pending DIOs */
4331         }
4332
4333         rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, NBPP);
4334         ilen = len + (offset & (rounding - 1));
4335         ioffset = offset & ~(rounding - 1);
4336         if (ilen & (rounding - 1))
4337                 ilen = (ilen + rounding) & ~(rounding - 1);
4338
4339         if (VN_CACHED(vp) != 0) {
4340                 xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
4341                                 ctooff(offtoct(ioffset)), -1);
4342                 bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
4343                                 -1, FI_REMAPF_LOCKED);
4344         }
4345
4346         /*
4347          * Need to zero the stuff we're not freeing, on disk.
4348          * If its a realtime file & can't use unwritten extents then we
4349          * actually need to zero the extent edges.  Otherwise xfs_bunmapi
4350          * will take care of it for us.
4351          */
4352         if (rt && !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
4353                 nimap = 1;
4354                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, startoffset_fsb,
4355                         1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
4356                 if (error)
4357                         goto out_unlock_iolock;
4358                 ASSERT(nimap == 0 || nimap == 1);
4359                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
4360                         xfs_daddr_t     block;
4361
4362                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4363                         block = imap.br_startblock;
4364                         mod = do_div(block, mp->m_sb.sb_rextsize);
4365                         if (mod)
4366                                 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
4367                 }
4368                 nimap = 1;
4369                 error = XFS_BMAPI(mp, NULL, &ip->i_iocore, endoffset_fsb - 1,
4370                         1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
4371                 if (error)
4372                         goto out_unlock_iolock;
4373                 ASSERT(nimap == 0 || nimap == 1);
4374                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
4375                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
4376                         mod++;
4377                         if (mod && (mod != mp->m_sb.sb_rextsize))
4378                                 endoffset_fsb -= mod;
4379                 }
4380         }
4381         if ((done = (endoffset_fsb <= startoffset_fsb)))
4382                 /*
4383                  * One contiguous piece to clear
4384                  */
4385                 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
4386         else {
4387                 /*
4388                  * Some full blocks, possibly two pieces to clear
4389                  */
4390                 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
4391                         error = xfs_zero_remaining_bytes(ip, offset,
4392                                 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
4393                 if (!error &&
4394                     XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
4395                         error = xfs_zero_remaining_bytes(ip,
4396                                 XFS_FSB_TO_B(mp, endoffset_fsb),
4397                                 offset + len - 1);
4398         }
4399
4400         /*
4401          * free file space until done or until there is an error
4402          */
4403         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
4404         while (!error && !done) {
4405
4406                 /*
4407                  * allocate and setup the transaction
4408                  */
4409                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
4410                 error = xfs_trans_reserve(tp,
4411                                           resblks,
4412                                           XFS_WRITE_LOG_RES(mp),
4413                                           0,
4414                                           XFS_TRANS_PERM_LOG_RES,
4415                                           XFS_WRITE_LOG_COUNT);
4416
4417                 /*
4418                  * check for running out of space
4419                  */
4420                 if (error) {
4421                         /*
4422                          * Free the transaction structure.
4423                          */
4424                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
4425                         xfs_trans_cancel(tp, 0);
4426                         break;
4427                 }
4428                 xfs_ilock(ip, XFS_ILOCK_EXCL);
4429                 error = XFS_TRANS_RESERVE_QUOTA(mp, tp,
4430                                 ip->i_udquot, ip->i_gdquot, resblks, 0,
4431                                 XFS_QMOPT_RES_REGBLKS);
4432                 if (error)
4433                         goto error1;
4434
4435                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4436                 xfs_trans_ihold(tp, ip);
4437
4438                 /*
4439                  * issue the bunmapi() call to free the blocks
4440                  */
4441                 XFS_BMAP_INIT(&free_list, &firstfsb);
4442                 error = XFS_BUNMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
4443                                   endoffset_fsb - startoffset_fsb,
4444                                   0, 2, &firstfsb, &free_list, NULL, &done);
4445                 if (error) {
4446                         goto error0;
4447                 }
4448
4449                 /*
4450                  * complete the transaction
4451                  */
4452                 error = xfs_bmap_finish(&tp, &free_list, &committed);
4453                 if (error) {
4454                         goto error0;
4455                 }
4456
4457                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
4458                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4459         }
4460
4461  out_unlock_iolock:
4462         if (need_iolock)
4463                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
4464         return error;
4465
4466  error0:
4467         xfs_bmap_cancel(&free_list);
4468  error1:
4469         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
4470         xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
4471                     XFS_ILOCK_EXCL);
4472         return error;
4473 }
4474
4475 /*
4476  * xfs_change_file_space()
4477  *      This routine allocates or frees disk space for the given file.
4478  *      The user specified parameters are checked for alignment and size
4479  *      limitations.
4480  *
4481  * RETURNS:
4482  *       0 on success
4483  *      errno on error
4484  *
4485  */
4486 int
4487 xfs_change_file_space(
4488         bhv_desc_t      *bdp,
4489         int             cmd,
4490         xfs_flock64_t   *bf,
4491         xfs_off_t       offset,
4492         cred_t          *credp,
4493         int             attr_flags)
4494 {
4495         int             clrprealloc;
4496         int             error;
4497         xfs_fsize_t     fsize;
4498         xfs_inode_t     *ip;
4499         xfs_mount_t     *mp;
4500         int             setprealloc;
4501         xfs_off_t       startoffset;
4502         xfs_off_t       llen;
4503         xfs_trans_t     *tp;
4504         bhv_vattr_t     va;
4505         bhv_vnode_t     *vp;
4506
4507         vp = BHV_TO_VNODE(bdp);
4508         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
4509
4510         ip = XFS_BHVTOI(bdp);
4511         mp = ip->i_mount;
4512
4513         /*
4514          * must be a regular file and have write permission
4515          */
4516         if (!VN_ISREG(vp))
4517                 return XFS_ERROR(EINVAL);
4518
4519         xfs_ilock(ip, XFS_ILOCK_SHARED);
4520
4521         if ((error = xfs_iaccess(ip, S_IWUSR, credp))) {
4522                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
4523                 return error;
4524         }
4525
4526         xfs_iunlock(ip, XFS_ILOCK_SHARED);
4527
4528         switch (bf->l_whence) {
4529         case 0: /*SEEK_SET*/
4530                 break;
4531         case 1: /*SEEK_CUR*/
4532                 bf->l_start += offset;
4533                 break;
4534         case 2: /*SEEK_END*/
4535                 bf->l_start += ip->i_d.di_size;
4536                 break;
4537         default:
4538                 return XFS_ERROR(EINVAL);
4539         }
4540
4541         llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
4542
4543         if (   (bf->l_start < 0)
4544             || (bf->l_start > XFS_MAXIOFFSET(mp))
4545             || (bf->l_start + llen < 0)
4546             || (bf->l_start + llen > XFS_MAXIOFFSET(mp)))
4547                 return XFS_ERROR(EINVAL);
4548
4549         bf->l_whence = 0;
4550
4551         startoffset = bf->l_start;
4552         fsize = ip->i_d.di_size;
4553
4554         /*
4555          * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
4556          * file space.
4557          * These calls do NOT zero the data space allocated to the file,
4558          * nor do they change the file size.
4559          *
4560          * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
4561          * space.
4562          * These calls cause the new file data to be zeroed and the file
4563          * size to be changed.
4564          */
4565         setprealloc = clrprealloc = 0;
4566
4567         switch (cmd) {
4568         case XFS_IOC_RESVSP:
4569         case XFS_IOC_RESVSP64:
4570                 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
4571                                                                 1, attr_flags);
4572                 if (error)
4573                         return error;
4574                 setprealloc = 1;
4575                 break;
4576
4577         case XFS_IOC_UNRESVSP:
4578         case XFS_IOC_UNRESVSP64:
4579                 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
4580                                                                 attr_flags)))
4581                         return error;
4582                 break;
4583
4584         case XFS_IOC_ALLOCSP:
4585         case XFS_IOC_ALLOCSP64:
4586         case XFS_IOC_FREESP:
4587         case XFS_IOC_FREESP64:
4588                 if (startoffset > fsize) {
4589                         error = xfs_alloc_file_space(ip, fsize,
4590                                         startoffset - fsize, 0, attr_flags);
4591                         if (error)
4592                                 break;
4593                 }
4594
4595                 va.va_mask = XFS_AT_SIZE;
4596                 va.va_size = startoffset;
4597
4598                 error = xfs_setattr(bdp, &va, attr_flags, credp);
4599
4600                 if (error)
4601                         return error;
4602
4603                 clrprealloc = 1;
4604                 break;
4605
4606         default:
4607                 ASSERT(0);
4608                 return XFS_ERROR(EINVAL);
4609         }
4610
4611         /*
4612          * update the inode timestamp, mode, and prealloc flag bits
4613          */
4614         tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
4615
4616         if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
4617                                       0, 0, 0))) {
4618                 /* ASSERT(0); */
4619                 xfs_trans_cancel(tp, 0);
4620                 return error;
4621         }
4622
4623         xfs_ilock(ip, XFS_ILOCK_EXCL);
4624
4625         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
4626         xfs_trans_ihold(tp, ip);
4627
4628         if ((attr_flags & ATTR_DMI) == 0) {
4629                 ip->i_d.di_mode &= ~S_ISUID;
4630
4631                 /*
4632                  * Note that we don't have to worry about mandatory
4633                  * file locking being disabled here because we only
4634                  * clear the S_ISGID bit if the Group execute bit is
4635                  * on, but if it was on then mandatory locking wouldn't
4636                  * have been enabled.
4637                  */
4638                 if (ip->i_d.di_mode & S_IXGRP)
4639                         ip->i_d.di_mode &= ~S_ISGID;
4640
4641                 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
4642         }
4643         if (setprealloc)
4644                 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
4645         else if (clrprealloc)
4646                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
4647
4648         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4649         xfs_trans_set_sync(tp);
4650
4651         error = xfs_trans_commit(tp, 0);
4652
4653         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4654
4655         return error;
4656 }
4657
4658 bhv_vnodeops_t xfs_vnodeops = {
4659         BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
4660         .vop_open               = xfs_open,
4661         .vop_close              = xfs_close,
4662         .vop_read               = xfs_read,
4663 #ifdef HAVE_SENDFILE
4664         .vop_sendfile           = xfs_sendfile,
4665 #endif
4666 #ifdef HAVE_SPLICE
4667         .vop_splice_read        = xfs_splice_read,
4668         .vop_splice_write       = xfs_splice_write,
4669 #endif
4670         .vop_write              = xfs_write,
4671         .vop_ioctl              = xfs_ioctl,
4672         .vop_getattr            = xfs_getattr,
4673         .vop_setattr            = xfs_setattr,
4674         .vop_access             = xfs_access,
4675         .vop_lookup             = xfs_lookup,
4676         .vop_create             = xfs_create,
4677         .vop_remove             = xfs_remove,
4678         .vop_link               = xfs_link,
4679         .vop_rename             = xfs_rename,
4680         .vop_mkdir              = xfs_mkdir,
4681         .vop_rmdir              = xfs_rmdir,
4682         .vop_readdir            = xfs_readdir,
4683         .vop_symlink            = xfs_symlink,
4684         .vop_readlink           = xfs_readlink,
4685         .vop_fsync              = xfs_fsync,
4686         .vop_inactive           = xfs_inactive,
4687         .vop_fid2               = xfs_fid2,
4688         .vop_rwlock             = xfs_rwlock,
4689         .vop_rwunlock           = xfs_rwunlock,
4690         .vop_bmap               = xfs_bmap,
4691         .vop_reclaim            = xfs_reclaim,
4692         .vop_attr_get           = xfs_attr_get,
4693         .vop_attr_set           = xfs_attr_set,
4694         .vop_attr_remove        = xfs_attr_remove,
4695         .vop_attr_list          = xfs_attr_list,
4696         .vop_link_removed       = (vop_link_removed_t)fs_noval,
4697         .vop_vnode_change       = (vop_vnode_change_t)fs_noval,
4698         .vop_tosspages          = fs_tosspages,
4699         .vop_flushinval_pages   = fs_flushinval_pages,
4700         .vop_flush_pages        = fs_flush_pages,
4701         .vop_release            = xfs_release,
4702         .vop_iflush             = xfs_inode_flush,
4703 };