fs/xfs/xfs_vnodeops.c

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