fs/xfs/xfs_vnodeops.c

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