fs/xfs/xfs_vnodeops.c

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