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