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