fs/xfs/xfs_vnodeops.c

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