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