i386: Allow KVM on i386 nonpae
[sfrench/cifs-2.6.git] / fs / xfs / xfs_vnodeops.c
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #include "xfs.h"
20 #include "xfs_fs.h"
21 #include "xfs_types.h"
22 #include "xfs_bit.h"
23 #include "xfs_log.h"
24 #include "xfs_inum.h"
25 #include "xfs_trans.h"
26 #include "xfs_sb.h"
27 #include "xfs_ag.h"
28 #include "xfs_dir2.h"
29 #include "xfs_dmapi.h"
30 #include "xfs_mount.h"
31 #include "xfs_da_btree.h"
32 #include "xfs_bmap_btree.h"
33 #include "xfs_alloc_btree.h"
34 #include "xfs_ialloc_btree.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_attr_sf.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
39 #include "xfs_inode_item.h"
40 #include "xfs_itable.h"
41 #include "xfs_btree.h"
42 #include "xfs_ialloc.h"
43 #include "xfs_alloc.h"
44 #include "xfs_bmap.h"
45 #include "xfs_attr.h"
46 #include "xfs_rw.h"
47 #include "xfs_error.h"
48 #include "xfs_quota.h"
49 #include "xfs_utils.h"
50 #include "xfs_rtalloc.h"
51 #include "xfs_refcache.h"
52 #include "xfs_trans_space.h"
53 #include "xfs_log_priv.h"
54 #include "xfs_filestream.h"
55
56 STATIC int
57 xfs_open(
58         bhv_desc_t      *bdp,
59         cred_t          *credp)
60 {
61         int             mode;
62         bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
63         xfs_inode_t     *ip = XFS_BHVTOI(bdp);
64
65         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
66                 return XFS_ERROR(EIO);
67
68         /*
69          * If it's a directory with any blocks, read-ahead block 0
70          * as we're almost certain to have the next operation be a read there.
71          */
72         if (VN_ISDIR(vp) && ip->i_d.di_nextents > 0) {
73                 mode = xfs_ilock_map_shared(ip);
74                 if (ip->i_d.di_nextents > 0)
75                         (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK);
76                 xfs_iunlock(ip, mode);
77         }
78         return 0;
79 }
80
81 /*
82  * xfs_getattr
83  */
84 STATIC int
85 xfs_getattr(
86         bhv_desc_t      *bdp,
87         bhv_vattr_t     *vap,
88         int             flags,
89         cred_t          *credp)
90 {
91         xfs_inode_t     *ip;
92         xfs_mount_t     *mp;
93         bhv_vnode_t     *vp;
94
95         vp  = BHV_TO_VNODE(bdp);
96         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
97
98         ip = XFS_BHVTOI(bdp);
99         mp = ip->i_mount;
100
101         if (XFS_FORCED_SHUTDOWN(mp))
102                 return XFS_ERROR(EIO);
103
104         if (!(flags & ATTR_LAZY))
105                 xfs_ilock(ip, XFS_ILOCK_SHARED);
106
107         vap->va_size = XFS_ISIZE(ip);
108         if (vap->va_mask == XFS_AT_SIZE)
109                 goto all_done;
110
111         vap->va_nblocks =
112                 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
113         vap->va_nodeid = ip->i_ino;
114 #if XFS_BIG_INUMS
115         vap->va_nodeid += mp->m_inoadd;
116 #endif
117         vap->va_nlink = ip->i_d.di_nlink;
118
119         /*
120          * Quick exit for non-stat callers
121          */
122         if ((vap->va_mask &
123             ~(XFS_AT_SIZE|XFS_AT_FSID|XFS_AT_NODEID|
124               XFS_AT_NLINK|XFS_AT_BLKSIZE)) == 0)
125                 goto all_done;
126
127         /*
128          * Copy from in-core inode.
129          */
130         vap->va_mode = ip->i_d.di_mode;
131         vap->va_uid = ip->i_d.di_uid;
132         vap->va_gid = ip->i_d.di_gid;
133         vap->va_projid = ip->i_d.di_projid;
134
135         /*
136          * Check vnode type block/char vs. everything else.
137          */
138         switch (ip->i_d.di_mode & S_IFMT) {
139         case S_IFBLK:
140         case S_IFCHR:
141                 vap->va_rdev = ip->i_df.if_u2.if_rdev;
142                 vap->va_blocksize = BLKDEV_IOSIZE;
143                 break;
144         default:
145                 vap->va_rdev = 0;
146
147                 if (!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) {
148                         vap->va_blocksize = xfs_preferred_iosize(mp);
149                 } else {
150
151                         /*
152                          * If the file blocks are being allocated from a
153                          * realtime partition, then return the inode's
154                          * realtime extent size or the realtime volume's
155                          * extent size.
156                          */
157                         vap->va_blocksize =
158                                 xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
159                 }
160                 break;
161         }
162
163         vn_atime_to_timespec(vp, &vap->va_atime);
164         vap->va_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
165         vap->va_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
166         vap->va_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
167         vap->va_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
168
169         /*
170          * Exit for stat callers.  See if any of the rest of the fields
171          * to be filled in are needed.
172          */
173         if ((vap->va_mask &
174              (XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|
175               XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0)
176                 goto all_done;
177
178         /*
179          * Convert di_flags to xflags.
180          */
181         vap->va_xflags = xfs_ip2xflags(ip);
182
183         /*
184          * Exit for inode revalidate.  See if any of the rest of
185          * the fields to be filled in are needed.
186          */
187         if ((vap->va_mask &
188              (XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|
189               XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0)
190                 goto all_done;
191
192         vap->va_extsize = ip->i_d.di_extsize << mp->m_sb.sb_blocklog;
193         vap->va_nextents =
194                 (ip->i_df.if_flags & XFS_IFEXTENTS) ?
195                         ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) :
196                         ip->i_d.di_nextents;
197         if (ip->i_afp)
198                 vap->va_anextents =
199                         (ip->i_afp->if_flags & XFS_IFEXTENTS) ?
200                                 ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) :
201                                  ip->i_d.di_anextents;
202         else
203                 vap->va_anextents = 0;
204         vap->va_gen = ip->i_d.di_gen;
205
206  all_done:
207         if (!(flags & ATTR_LAZY))
208                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
209         return 0;
210 }
211
212
213 /*
214  * xfs_setattr
215  */
216 int
217 xfs_setattr(
218         bhv_desc_t              *bdp,
219         bhv_vattr_t             *vap,
220         int                     flags,
221         cred_t                  *credp)
222 {
223         xfs_inode_t             *ip;
224         xfs_trans_t             *tp;
225         xfs_mount_t             *mp;
226         int                     mask;
227         int                     code;
228         uint                    lock_flags;
229         uint                    commit_flags=0;
230         uid_t                   uid=0, iuid=0;
231         gid_t                   gid=0, igid=0;
232         int                     timeflags = 0;
233         bhv_vnode_t             *vp;
234         xfs_prid_t              projid=0, iprojid=0;
235         int                     mandlock_before, mandlock_after;
236         struct xfs_dquot        *udqp, *gdqp, *olddquot1, *olddquot2;
237         int                     file_owner;
238         int                     need_iolock = 1;
239
240         vp = BHV_TO_VNODE(bdp);
241         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
242
243         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
244                 return XFS_ERROR(EROFS);
245
246         /*
247          * Cannot set certain attributes.
248          */
249         mask = vap->va_mask;
250         if (mask & XFS_AT_NOSET) {
251                 return XFS_ERROR(EINVAL);
252         }
253
254         ip = XFS_BHVTOI(bdp);
255         mp = ip->i_mount;
256
257         if (XFS_FORCED_SHUTDOWN(mp))
258                 return XFS_ERROR(EIO);
259
260         /*
261          * Timestamps do not need to be logged and hence do not
262          * need to be done within a transaction.
263          */
264         if (mask & XFS_AT_UPDTIMES) {
265                 ASSERT((mask & ~XFS_AT_UPDTIMES) == 0);
266                 timeflags = ((mask & XFS_AT_UPDATIME) ? XFS_ICHGTIME_ACC : 0) |
267                             ((mask & XFS_AT_UPDCTIME) ? XFS_ICHGTIME_CHG : 0) |
268                             ((mask & XFS_AT_UPDMTIME) ? XFS_ICHGTIME_MOD : 0);
269                 xfs_ichgtime(ip, timeflags);
270                 return 0;
271         }
272
273         olddquot1 = olddquot2 = NULL;
274         udqp = gdqp = NULL;
275
276         /*
277          * If disk quotas is on, we make sure that the dquots do exist on disk,
278          * before we start any other transactions. Trying to do this later
279          * is messy. We don't care to take a readlock to look at the ids
280          * in inode here, because we can't hold it across the trans_reserve.
281          * If the IDs do change before we take the ilock, we're covered
282          * because the i_*dquot fields will get updated anyway.
283          */
284         if (XFS_IS_QUOTA_ON(mp) &&
285             (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID))) {
286                 uint    qflags = 0;
287
288                 if ((mask & XFS_AT_UID) && XFS_IS_UQUOTA_ON(mp)) {
289                         uid = vap->va_uid;
290                         qflags |= XFS_QMOPT_UQUOTA;
291                 } else {
292                         uid = ip->i_d.di_uid;
293                 }
294                 if ((mask & XFS_AT_GID) && XFS_IS_GQUOTA_ON(mp)) {
295                         gid = vap->va_gid;
296                         qflags |= XFS_QMOPT_GQUOTA;
297                 }  else {
298                         gid = ip->i_d.di_gid;
299                 }
300                 if ((mask & XFS_AT_PROJID) && XFS_IS_PQUOTA_ON(mp)) {
301                         projid = vap->va_projid;
302                         qflags |= XFS_QMOPT_PQUOTA;
303                 }  else {
304                         projid = ip->i_d.di_projid;
305                 }
306                 /*
307                  * We take a reference when we initialize udqp and gdqp,
308                  * so it is important that we never blindly double trip on
309                  * the same variable. See xfs_create() for an example.
310                  */
311                 ASSERT(udqp == NULL);
312                 ASSERT(gdqp == NULL);
313                 code = XFS_QM_DQVOPALLOC(mp, ip, uid, gid, projid, qflags,
314                                          &udqp, &gdqp);
315                 if (code)
316                         return code;
317         }
318
319         /*
320          * For the other attributes, we acquire the inode lock and
321          * first do an error checking pass.
322          */
323         tp = NULL;
324         lock_flags = XFS_ILOCK_EXCL;
325         if (flags & ATTR_NOLOCK)
326                 need_iolock = 0;
327         if (!(mask & XFS_AT_SIZE)) {
328                 if ((mask != (XFS_AT_CTIME|XFS_AT_ATIME|XFS_AT_MTIME)) ||
329                     (mp->m_flags & XFS_MOUNT_WSYNC)) {
330                         tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
331                         commit_flags = 0;
332                         if ((code = xfs_trans_reserve(tp, 0,
333                                                      XFS_ICHANGE_LOG_RES(mp), 0,
334                                                      0, 0))) {
335                                 lock_flags = 0;
336                                 goto error_return;
337                         }
338                 }
339         } else {
340                 if (DM_EVENT_ENABLED (vp->v_vfsp, ip, DM_EVENT_TRUNCATE) &&
341                     !(flags & ATTR_DMI)) {
342                         int dmflags = AT_DELAY_FLAG(flags) | DM_SEM_FLAG_WR;
343                         code = XFS_SEND_DATA(mp, DM_EVENT_TRUNCATE, vp,
344                                 vap->va_size, 0, dmflags, NULL);
345                         if (code) {
346                                 lock_flags = 0;
347                                 goto error_return;
348                         }
349                 }
350                 if (need_iolock)
351                         lock_flags |= XFS_IOLOCK_EXCL;
352         }
353
354         xfs_ilock(ip, lock_flags);
355
356         /* boolean: are we the file owner? */
357         file_owner = (current_fsuid(credp) == ip->i_d.di_uid);
358
359         /*
360          * Change various properties of a file.
361          * Only the owner or users with CAP_FOWNER
362          * capability may do these things.
363          */
364         if (mask &
365             (XFS_AT_MODE|XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_UID|
366              XFS_AT_GID|XFS_AT_PROJID)) {
367                 /*
368                  * CAP_FOWNER overrides the following restrictions:
369                  *
370                  * The user ID of the calling process must be equal
371                  * to the file owner ID, except in cases where the
372                  * CAP_FSETID capability is applicable.
373                  */
374                 if (!file_owner && !capable(CAP_FOWNER)) {
375                         code = XFS_ERROR(EPERM);
376                         goto error_return;
377                 }
378
379                 /*
380                  * CAP_FSETID overrides the following restrictions:
381                  *
382                  * The effective user ID of the calling process shall match
383                  * the file owner when setting the set-user-ID and
384                  * set-group-ID bits on that file.
385                  *
386                  * The effective group ID or one of the supplementary group
387                  * IDs of the calling process shall match the group owner of
388                  * the file when setting the set-group-ID bit on that file
389                  */
390                 if (mask & XFS_AT_MODE) {
391                         mode_t m = 0;
392
393                         if ((vap->va_mode & S_ISUID) && !file_owner)
394                                 m |= S_ISUID;
395                         if ((vap->va_mode & S_ISGID) &&
396                             !in_group_p((gid_t)ip->i_d.di_gid))
397                                 m |= S_ISGID;
398 #if 0
399                         /* Linux allows this, Irix doesn't. */
400                         if ((vap->va_mode & S_ISVTX) && !VN_ISDIR(vp))
401                                 m |= S_ISVTX;
402 #endif
403                         if (m && !capable(CAP_FSETID))
404                                 vap->va_mode &= ~m;
405                 }
406         }
407
408         /*
409          * Change file ownership.  Must be the owner or privileged.
410          * If the system was configured with the "restricted_chown"
411          * option, the owner is not permitted to give away the file,
412          * and can change the group id only to a group of which he
413          * or she is a member.
414          */
415         if (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID)) {
416                 /*
417                  * These IDs could have changed since we last looked at them.
418                  * But, we're assured that if the ownership did change
419                  * while we didn't have the inode locked, inode's dquot(s)
420                  * would have changed also.
421                  */
422                 iuid = ip->i_d.di_uid;
423                 iprojid = ip->i_d.di_projid;
424                 igid = ip->i_d.di_gid;
425                 gid = (mask & XFS_AT_GID) ? vap->va_gid : igid;
426                 uid = (mask & XFS_AT_UID) ? vap->va_uid : iuid;
427                 projid = (mask & XFS_AT_PROJID) ? (xfs_prid_t)vap->va_projid :
428                          iprojid;
429
430                 /*
431                  * CAP_CHOWN overrides the following restrictions:
432                  *
433                  * If _POSIX_CHOWN_RESTRICTED is defined, this capability
434                  * shall override the restriction that a process cannot
435                  * change the user ID of a file it owns and the restriction
436                  * that the group ID supplied to the chown() function
437                  * shall be equal to either the group ID or one of the
438                  * supplementary group IDs of the calling process.
439                  */
440                 if (restricted_chown &&
441                     (iuid != uid || (igid != gid &&
442                                      !in_group_p((gid_t)gid))) &&
443                     !capable(CAP_CHOWN)) {
444                         code = XFS_ERROR(EPERM);
445                         goto error_return;
446                 }
447                 /*
448                  * Do a quota reservation only if uid/projid/gid is actually
449                  * going to change.
450                  */
451                 if ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||
452                     (XFS_IS_PQUOTA_ON(mp) && iprojid != projid) ||
453                     (XFS_IS_GQUOTA_ON(mp) && igid != gid)) {
454                         ASSERT(tp);
455                         code = XFS_QM_DQVOPCHOWNRESV(mp, tp, ip, udqp, gdqp,
456                                                 capable(CAP_FOWNER) ?
457                                                 XFS_QMOPT_FORCE_RES : 0);
458                         if (code)       /* out of quota */
459                                 goto error_return;
460                 }
461         }
462
463         /*
464          * Truncate file.  Must have write permission and not be a directory.
465          */
466         if (mask & XFS_AT_SIZE) {
467                 /* Short circuit the truncate case for zero length files */
468                 if ((vap->va_size == 0) &&
469                    (ip->i_size == 0) && (ip->i_d.di_nextents == 0)) {
470                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
471                         lock_flags &= ~XFS_ILOCK_EXCL;
472                         if (mask & XFS_AT_CTIME)
473                                 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
474                         code = 0;
475                         goto error_return;
476                 }
477
478                 if (VN_ISDIR(vp)) {
479                         code = XFS_ERROR(EISDIR);
480                         goto error_return;
481                 } else if (!VN_ISREG(vp)) {
482                         code = XFS_ERROR(EINVAL);
483                         goto error_return;
484                 }
485                 /*
486                  * Make sure that the dquots are attached to the inode.
487                  */
488                 if ((code = XFS_QM_DQATTACH(mp, ip, XFS_QMOPT_ILOCKED)))
489                         goto error_return;
490         }
491
492         /*
493          * Change file access or modified times.
494          */
495         if (mask & (XFS_AT_ATIME|XFS_AT_MTIME)) {
496                 if (!file_owner) {
497                         if ((flags & ATTR_UTIME) &&
498                             !capable(CAP_FOWNER)) {
499                                 code = XFS_ERROR(EPERM);
500                                 goto error_return;
501                         }
502                 }
503         }
504
505         /*
506          * Change extent size or realtime flag.
507          */
508         if (mask & (XFS_AT_EXTSIZE|XFS_AT_XFLAGS)) {
509                 /*
510                  * Can't change extent size if any extents are allocated.
511                  */
512                 if (ip->i_d.di_nextents && (mask & XFS_AT_EXTSIZE) &&
513                     ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
514                      vap->va_extsize) ) {
515                         code = XFS_ERROR(EINVAL);       /* EFBIG? */
516                         goto error_return;
517                 }
518
519                 /*
520                  * Can't change realtime flag if any extents are allocated.
521                  */
522                 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
523                     (mask & XFS_AT_XFLAGS) &&
524                     (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) !=
525                     (vap->va_xflags & XFS_XFLAG_REALTIME)) {
526                         code = XFS_ERROR(EINVAL);       /* EFBIG? */
527                         goto error_return;
528                 }
529                 /*
530                  * Extent size must be a multiple of the appropriate block
531                  * size, if set at all.
532                  */
533                 if ((mask & XFS_AT_EXTSIZE) && vap->va_extsize != 0) {
534                         xfs_extlen_t    size;
535
536                         if ((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ||
537                             ((mask & XFS_AT_XFLAGS) &&
538                             (vap->va_xflags & XFS_XFLAG_REALTIME))) {
539                                 size = mp->m_sb.sb_rextsize <<
540                                        mp->m_sb.sb_blocklog;
541                         } else {
542                                 size = mp->m_sb.sb_blocksize;
543                         }
544                         if (vap->va_extsize % size) {
545                                 code = XFS_ERROR(EINVAL);
546                                 goto error_return;
547                         }
548                 }
549                 /*
550                  * If realtime flag is set then must have realtime data.
551                  */
552                 if ((mask & XFS_AT_XFLAGS) &&
553                     (vap->va_xflags & XFS_XFLAG_REALTIME)) {
554                         if ((mp->m_sb.sb_rblocks == 0) ||
555                             (mp->m_sb.sb_rextsize == 0) ||
556                             (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
557                                 code = XFS_ERROR(EINVAL);
558                                 goto error_return;
559                         }
560                 }
561
562                 /*
563                  * Can't modify an immutable/append-only file unless
564                  * we have appropriate permission.
565                  */
566                 if ((mask & XFS_AT_XFLAGS) &&
567                     (ip->i_d.di_flags &
568                                 (XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
569                      (vap->va_xflags &
570                                 (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
571                     !capable(CAP_LINUX_IMMUTABLE)) {
572                         code = XFS_ERROR(EPERM);
573                         goto error_return;
574                 }
575         }
576
577         /*
578          * Now we can make the changes.  Before we join the inode
579          * to the transaction, if XFS_AT_SIZE is set then take care of
580          * the part of the truncation that must be done without the
581          * inode lock.  This needs to be done before joining the inode
582          * to the transaction, because the inode cannot be unlocked
583          * once it is a part of the transaction.
584          */
585         if (mask & XFS_AT_SIZE) {
586                 code = 0;
587                 if ((vap->va_size > ip->i_size) &&
588                     (flags & ATTR_NOSIZETOK) == 0) {
589                         code = xfs_igrow_start(ip, vap->va_size, credp);
590                 }
591                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
592                 vn_iowait(vp); /* wait for the completion of any pending DIOs */
593                 if (!code)
594                         code = xfs_itruncate_data(ip, vap->va_size);
595                 if (code) {
596                         ASSERT(tp == NULL);
597                         lock_flags &= ~XFS_ILOCK_EXCL;
598                         ASSERT(lock_flags == XFS_IOLOCK_EXCL);
599                         goto error_return;
600                 }
601                 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
602                 if ((code = xfs_trans_reserve(tp, 0,
603                                              XFS_ITRUNCATE_LOG_RES(mp), 0,
604                                              XFS_TRANS_PERM_LOG_RES,
605                                              XFS_ITRUNCATE_LOG_COUNT))) {
606                         xfs_trans_cancel(tp, 0);
607                         if (need_iolock)
608                                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
609                         return code;
610                 }
611                 commit_flags = XFS_TRANS_RELEASE_LOG_RES;
612                 xfs_ilock(ip, XFS_ILOCK_EXCL);
613         }
614
615         if (tp) {
616                 xfs_trans_ijoin(tp, ip, lock_flags);
617                 xfs_trans_ihold(tp, ip);
618         }
619
620         /* determine whether mandatory locking mode changes */
621         mandlock_before = MANDLOCK(vp, ip->i_d.di_mode);
622
623         /*
624          * Truncate file.  Must have write permission and not be a directory.
625          */
626         if (mask & XFS_AT_SIZE) {
627                 if (vap->va_size > ip->i_size) {
628                         xfs_igrow_finish(tp, ip, vap->va_size,
629                             !(flags & ATTR_DMI));
630                 } else if ((vap->va_size <= ip->i_size) ||
631                            ((vap->va_size == 0) && ip->i_d.di_nextents)) {
632                         /*
633                          * signal a sync transaction unless
634                          * we're truncating an already unlinked
635                          * file on a wsync filesystem
636                          */
637                         code = xfs_itruncate_finish(&tp, ip,
638                                             (xfs_fsize_t)vap->va_size,
639                                             XFS_DATA_FORK,
640                                             ((ip->i_d.di_nlink != 0 ||
641                                               !(mp->m_flags & XFS_MOUNT_WSYNC))
642                                              ? 1 : 0));
643                         if (code)
644                                 goto abort_return;
645                         /*
646                          * Truncated "down", so we're removing references
647                          * to old data here - if we now delay flushing for
648                          * a long time, we expose ourselves unduly to the
649                          * notorious NULL files problem.  So, we mark this
650                          * vnode and flush it when the file is closed, and
651                          * do not wait the usual (long) time for writeout.
652                          */
653                         VTRUNCATE(vp);
654                 }
655                 /*
656                  * Have to do this even if the file's size doesn't change.
657                  */
658                 timeflags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
659         }
660
661         /*
662          * Change file access modes.
663          */
664         if (mask & XFS_AT_MODE) {
665                 ip->i_d.di_mode &= S_IFMT;
666                 ip->i_d.di_mode |= vap->va_mode & ~S_IFMT;
667
668                 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
669                 timeflags |= XFS_ICHGTIME_CHG;
670         }
671
672         /*
673          * Change file ownership.  Must be the owner or privileged.
674          * If the system was configured with the "restricted_chown"
675          * option, the owner is not permitted to give away the file,
676          * and can change the group id only to a group of which he
677          * or she is a member.
678          */
679         if (mask & (XFS_AT_UID|XFS_AT_GID|XFS_AT_PROJID)) {
680                 /*
681                  * CAP_FSETID overrides the following restrictions:
682                  *
683                  * The set-user-ID and set-group-ID bits of a file will be
684                  * cleared upon successful return from chown()
685                  */
686                 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
687                     !capable(CAP_FSETID)) {
688                         ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
689                 }
690
691                 /*
692                  * Change the ownerships and register quota modifications
693                  * in the transaction.
694                  */
695                 if (iuid != uid) {
696                         if (XFS_IS_UQUOTA_ON(mp)) {
697                                 ASSERT(mask & XFS_AT_UID);
698                                 ASSERT(udqp);
699                                 olddquot1 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
700                                                         &ip->i_udquot, udqp);
701                         }
702                         ip->i_d.di_uid = uid;
703                 }
704                 if (igid != gid) {
705                         if (XFS_IS_GQUOTA_ON(mp)) {
706                                 ASSERT(!XFS_IS_PQUOTA_ON(mp));
707                                 ASSERT(mask & XFS_AT_GID);
708                                 ASSERT(gdqp);
709                                 olddquot2 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
710                                                         &ip->i_gdquot, gdqp);
711                         }
712                         ip->i_d.di_gid = gid;
713                 }
714                 if (iprojid != projid) {
715                         if (XFS_IS_PQUOTA_ON(mp)) {
716                                 ASSERT(!XFS_IS_GQUOTA_ON(mp));
717                                 ASSERT(mask & XFS_AT_PROJID);
718                                 ASSERT(gdqp);
719                                 olddquot2 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
720                                                         &ip->i_gdquot, gdqp);
721                         }
722                         ip->i_d.di_projid = projid;
723                         /*
724                          * We may have to rev the inode as well as
725                          * the superblock version number since projids didn't
726                          * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
727                          */
728                         if (ip->i_d.di_version == XFS_DINODE_VERSION_1)
729                                 xfs_bump_ino_vers2(tp, ip);
730                 }
731
732                 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
733                 timeflags |= XFS_ICHGTIME_CHG;
734         }
735
736
737         /*
738          * Change file access or modified times.
739          */
740         if (mask & (XFS_AT_ATIME|XFS_AT_MTIME)) {
741                 if (mask & XFS_AT_ATIME) {
742                         ip->i_d.di_atime.t_sec = vap->va_atime.tv_sec;
743                         ip->i_d.di_atime.t_nsec = vap->va_atime.tv_nsec;
744                         ip->i_update_core = 1;
745                         timeflags &= ~XFS_ICHGTIME_ACC;
746                 }
747                 if (mask & XFS_AT_MTIME) {
748                         ip->i_d.di_mtime.t_sec = vap->va_mtime.tv_sec;
749                         ip->i_d.di_mtime.t_nsec = vap->va_mtime.tv_nsec;
750                         timeflags &= ~XFS_ICHGTIME_MOD;
751                         timeflags |= XFS_ICHGTIME_CHG;
752                 }
753                 if (tp && (flags & ATTR_UTIME))
754                         xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
755         }
756
757         /*
758          * Change XFS-added attributes.
759          */
760         if (mask & (XFS_AT_EXTSIZE|XFS_AT_XFLAGS)) {
761                 if (mask & XFS_AT_EXTSIZE) {
762                         /*
763                          * Converting bytes to fs blocks.
764                          */
765                         ip->i_d.di_extsize = vap->va_extsize >>
766                                 mp->m_sb.sb_blocklog;
767                 }
768                 if (mask & XFS_AT_XFLAGS) {
769                         uint    di_flags;
770
771                         /* can't set PREALLOC this way, just preserve it */
772                         di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
773                         if (vap->va_xflags & XFS_XFLAG_IMMUTABLE)
774                                 di_flags |= XFS_DIFLAG_IMMUTABLE;
775                         if (vap->va_xflags & XFS_XFLAG_APPEND)
776                                 di_flags |= XFS_DIFLAG_APPEND;
777                         if (vap->va_xflags & XFS_XFLAG_SYNC)
778                                 di_flags |= XFS_DIFLAG_SYNC;
779                         if (vap->va_xflags & XFS_XFLAG_NOATIME)
780                                 di_flags |= XFS_DIFLAG_NOATIME;
781                         if (vap->va_xflags & XFS_XFLAG_NODUMP)
782                                 di_flags |= XFS_DIFLAG_NODUMP;
783                         if (vap->va_xflags & XFS_XFLAG_PROJINHERIT)
784                                 di_flags |= XFS_DIFLAG_PROJINHERIT;
785                         if (vap->va_xflags & XFS_XFLAG_NODEFRAG)
786                                 di_flags |= XFS_DIFLAG_NODEFRAG;
787                         if (vap->va_xflags & XFS_XFLAG_FILESTREAM)
788                                 di_flags |= XFS_DIFLAG_FILESTREAM;
789                         if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
790                                 if (vap->va_xflags & XFS_XFLAG_RTINHERIT)
791                                         di_flags |= XFS_DIFLAG_RTINHERIT;
792                                 if (vap->va_xflags & XFS_XFLAG_NOSYMLINKS)
793                                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
794                                 if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT)
795                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
796                         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
797                                 if (vap->va_xflags & XFS_XFLAG_REALTIME) {
798                                         di_flags |= XFS_DIFLAG_REALTIME;
799                                         ip->i_iocore.io_flags |= XFS_IOCORE_RT;
800                                 } else {
801                                         ip->i_iocore.io_flags &= ~XFS_IOCORE_RT;
802                                 }
803                                 if (vap->va_xflags & XFS_XFLAG_EXTSIZE)
804                                         di_flags |= XFS_DIFLAG_EXTSIZE;
805                         }
806                         ip->i_d.di_flags = di_flags;
807                 }
808                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
809                 timeflags |= XFS_ICHGTIME_CHG;
810         }
811
812         /*
813          * Change file inode change time only if XFS_AT_CTIME set
814          * AND we have been called by a DMI function.
815          */
816
817         if ( (flags & ATTR_DMI) && (mask & XFS_AT_CTIME) ) {
818                 ip->i_d.di_ctime.t_sec = vap->va_ctime.tv_sec;
819                 ip->i_d.di_ctime.t_nsec = vap->va_ctime.tv_nsec;
820                 ip->i_update_core = 1;
821                 timeflags &= ~XFS_ICHGTIME_CHG;
822         }
823
824         /*
825          * Send out timestamp changes that need to be set to the
826          * current time.  Not done when called by a DMI function.
827          */
828         if (timeflags && !(flags & ATTR_DMI))
829                 xfs_ichgtime(ip, timeflags);
830
831         XFS_STATS_INC(xs_ig_attrchg);
832
833         /*
834          * If this is a synchronous mount, make sure that the
835          * transaction goes to disk before returning to the user.
836          * This is slightly sub-optimal in that truncates require
837          * two sync transactions instead of one for wsync filesystems.
838          * One for the truncate and one for the timestamps since we
839          * don't want to change the timestamps unless we're sure the
840          * truncate worked.  Truncates are less than 1% of the laddis
841          * mix so this probably isn't worth the trouble to optimize.
842          */
843         code = 0;
844         if (tp) {
845                 if (mp->m_flags & XFS_MOUNT_WSYNC)
846                         xfs_trans_set_sync(tp);
847
848                 code = xfs_trans_commit(tp, commit_flags);
849         }
850
851         /*
852          * If the (regular) file's mandatory locking mode changed, then
853          * notify the vnode.  We do this under the inode lock to prevent
854          * racing calls to vop_vnode_change.
855          */
856         mandlock_after = MANDLOCK(vp, ip->i_d.di_mode);
857         if (mandlock_before != mandlock_after) {
858                 bhv_vop_vnode_change(vp, VCHANGE_FLAGS_ENF_LOCKING,
859                                  mandlock_after);
860         }
861
862         xfs_iunlock(ip, lock_flags);
863
864         /*
865          * Release any dquot(s) the inode had kept before chown.
866          */
867         XFS_QM_DQRELE(mp, olddquot1);
868         XFS_QM_DQRELE(mp, olddquot2);
869         XFS_QM_DQRELE(mp, udqp);
870         XFS_QM_DQRELE(mp, gdqp);
871
872         if (code) {
873                 return code;
874         }
875
876         if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_ATTRIBUTE) &&
877             !(flags & ATTR_DMI)) {
878                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, vp, DM_RIGHT_NULL,
879                                         NULL, DM_RIGHT_NULL, NULL, NULL,
880                                         0, 0, AT_DELAY_FLAG(flags));
881         }
882         return 0;
883
884  abort_return:
885         commit_flags |= XFS_TRANS_ABORT;
886         /* FALLTHROUGH */
887  error_return:
888         XFS_QM_DQRELE(mp, udqp);
889         XFS_QM_DQRELE(mp, gdqp);
890         if (tp) {
891                 xfs_trans_cancel(tp, commit_flags);
892         }
893         if (lock_flags != 0) {
894                 xfs_iunlock(ip, lock_flags);
895         }
896         return code;
897 }
898
899
900 /*
901  * xfs_access
902  * Null conversion from vnode mode bits to inode mode bits, as in efs.
903  */
904 STATIC int
905 xfs_access(
906         bhv_desc_t      *bdp,
907         int             mode,
908         cred_t          *credp)
909 {
910         xfs_inode_t     *ip;
911         int             error;
912
913         vn_trace_entry(BHV_TO_VNODE(bdp), __FUNCTION__,
914                                                (inst_t *)__return_address);
915
916         ip = XFS_BHVTOI(bdp);
917         xfs_ilock(ip, XFS_ILOCK_SHARED);
918         error = xfs_iaccess(ip, mode, credp);
919         xfs_iunlock(ip, XFS_ILOCK_SHARED);
920         return error;
921 }
922
923
924 /*
925  * The maximum pathlen is 1024 bytes. Since the minimum file system
926  * blocksize is 512 bytes, we can get a max of 2 extents back from
927  * bmapi.
928  */
929 #define SYMLINK_MAPS 2
930
931 /*
932  * xfs_readlink
933  *
934  */
935 STATIC int
936 xfs_readlink(
937         bhv_desc_t      *bdp,
938         uio_t           *uiop,
939         int             ioflags,
940         cred_t          *credp)
941 {
942         xfs_inode_t     *ip;
943         int             count;
944         xfs_off_t       offset;
945         int             pathlen;
946         bhv_vnode_t     *vp;
947         int             error = 0;
948         xfs_mount_t     *mp;
949         int             nmaps;
950         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
951         xfs_daddr_t     d;
952         int             byte_cnt;
953         int             n;
954         xfs_buf_t       *bp;
955
956         vp = BHV_TO_VNODE(bdp);
957         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
958
959         ip = XFS_BHVTOI(bdp);
960         mp = ip->i_mount;
961
962         if (XFS_FORCED_SHUTDOWN(mp))
963                 return XFS_ERROR(EIO);
964
965         xfs_ilock(ip, XFS_ILOCK_SHARED);
966
967         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
968
969         offset = uiop->uio_offset;
970         count = uiop->uio_resid;
971
972         if (offset < 0) {
973                 error = XFS_ERROR(EINVAL);
974                 goto error_return;
975         }
976         if (count <= 0) {
977                 error = 0;
978                 goto error_return;
979         }
980
981         /*
982          * See if the symlink is stored inline.
983          */
984         pathlen = (int)ip->i_d.di_size;
985
986         if (ip->i_df.if_flags & XFS_IFINLINE) {
987                 error = xfs_uio_read(ip->i_df.if_u1.if_data, pathlen, uiop);
988         }
989         else {
990                 /*
991                  * Symlink not inline.  Call bmap to get it in.
992                  */
993                 nmaps = SYMLINK_MAPS;
994
995                 error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen),
996                                   0, NULL, 0, mval, &nmaps, NULL, NULL);
997
998                 if (error) {
999                         goto error_return;
1000                 }
1001
1002                 for (n = 0; n < nmaps; n++) {
1003                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
1004                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
1005                         bp = xfs_buf_read(mp->m_ddev_targp, d,
1006                                       BTOBB(byte_cnt), 0);
1007                         error = XFS_BUF_GETERROR(bp);
1008                         if (error) {
1009                                 xfs_ioerror_alert("xfs_readlink",
1010                                           ip->i_mount, bp, XFS_BUF_ADDR(bp));
1011                                 xfs_buf_relse(bp);
1012                                 goto error_return;
1013                         }
1014                         if (pathlen < byte_cnt)
1015                                 byte_cnt = pathlen;
1016                         pathlen -= byte_cnt;
1017
1018                         error = xfs_uio_read(XFS_BUF_PTR(bp), byte_cnt, uiop);
1019                         xfs_buf_relse (bp);
1020                 }
1021
1022         }
1023
1024 error_return:
1025         xfs_iunlock(ip, XFS_ILOCK_SHARED);
1026         return error;
1027 }
1028
1029
1030 /*
1031  * xfs_fsync
1032  *
1033  * This is called to sync the inode and its data out to disk.
1034  * We need to hold the I/O lock while flushing the data, and
1035  * the inode lock while flushing the inode.  The inode lock CANNOT
1036  * be held while flushing the data, so acquire after we're done
1037  * with that.
1038  */
1039 STATIC int
1040 xfs_fsync(
1041         bhv_desc_t      *bdp,
1042         int             flag,
1043         cred_t          *credp,
1044         xfs_off_t       start,
1045         xfs_off_t       stop)
1046 {
1047         xfs_inode_t     *ip;
1048         xfs_trans_t     *tp;
1049         int             error;
1050         int             log_flushed = 0, changed = 1;
1051
1052         vn_trace_entry(BHV_TO_VNODE(bdp),
1053                         __FUNCTION__, (inst_t *)__return_address);
1054
1055         ip = XFS_BHVTOI(bdp);
1056
1057         ASSERT(start >= 0 && stop >= -1);
1058
1059         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
1060                 return XFS_ERROR(EIO);
1061
1062         /*
1063          * We always need to make sure that the required inode state
1064          * is safe on disk.  The vnode might be clean but because
1065          * of committed transactions that haven't hit the disk yet.
1066          * Likewise, there could be unflushed non-transactional
1067          * changes to the inode core that have to go to disk.
1068          *
1069          * The following code depends on one assumption:  that
1070          * any transaction that changes an inode logs the core
1071          * because it has to change some field in the inode core
1072          * (typically nextents or nblocks).  That assumption
1073          * implies that any transactions against an inode will
1074          * catch any non-transactional updates.  If inode-altering
1075          * transactions exist that violate this assumption, the
1076          * code breaks.  Right now, it figures that if the involved
1077          * update_* field is clear and the inode is unpinned, the
1078          * inode is clean.  Either it's been flushed or it's been
1079          * committed and the commit has hit the disk unpinning the inode.
1080          * (Note that xfs_inode_item_format() called at commit clears
1081          * the update_* fields.)
1082          */
1083         xfs_ilock(ip, XFS_ILOCK_SHARED);
1084
1085         /* If we are flushing data then we care about update_size
1086          * being set, otherwise we care about update_core
1087          */
1088         if ((flag & FSYNC_DATA) ?
1089                         (ip->i_update_size == 0) :
1090                         (ip->i_update_core == 0)) {
1091                 /*
1092                  * Timestamps/size haven't changed since last inode
1093                  * flush or inode transaction commit.  That means
1094                  * either nothing got written or a transaction
1095                  * committed which caught the updates.  If the
1096                  * latter happened and the transaction hasn't
1097                  * hit the disk yet, the inode will be still
1098                  * be pinned.  If it is, force the log.
1099                  */
1100
1101                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
1102
1103                 if (xfs_ipincount(ip)) {
1104                         _xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
1105                                       XFS_LOG_FORCE |
1106                                       ((flag & FSYNC_WAIT)
1107                                        ? XFS_LOG_SYNC : 0),
1108                                       &log_flushed);
1109                 } else {
1110                         /*
1111                          * If the inode is not pinned and nothing
1112                          * has changed we don't need to flush the
1113                          * cache.
1114                          */
1115                         changed = 0;
1116                 }
1117                 error = 0;
1118         } else  {
1119                 /*
1120                  * Kick off a transaction to log the inode
1121                  * core to get the updates.  Make it
1122                  * sync if FSYNC_WAIT is passed in (which
1123                  * is done by everybody but specfs).  The
1124                  * sync transaction will also force the log.
1125                  */
1126                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
1127                 tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_FSYNC_TS);
1128                 if ((error = xfs_trans_reserve(tp, 0,
1129                                 XFS_FSYNC_TS_LOG_RES(ip->i_mount),
1130                                 0, 0, 0)))  {
1131                         xfs_trans_cancel(tp, 0);
1132                         return error;
1133                 }
1134                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1135
1136                 /*
1137                  * Note - it's possible that we might have pushed
1138                  * ourselves out of the way during trans_reserve
1139                  * which would flush the inode.  But there's no
1140                  * guarantee that the inode buffer has actually
1141                  * gone out yet (it's delwri).  Plus the buffer
1142                  * could be pinned anyway if it's part of an
1143                  * inode in another recent transaction.  So we
1144                  * play it safe and fire off the transaction anyway.
1145                  */
1146                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1147                 xfs_trans_ihold(tp, ip);
1148                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1149                 if (flag & FSYNC_WAIT)
1150                         xfs_trans_set_sync(tp);
1151                 error = _xfs_trans_commit(tp, 0, &log_flushed);
1152
1153                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1154         }
1155
1156         if ((ip->i_mount->m_flags & XFS_MOUNT_BARRIER) && changed) {
1157                 /*
1158                  * If the log write didn't issue an ordered tag we need
1159                  * to flush the disk cache for the data device now.
1160                  */
1161                 if (!log_flushed)
1162                         xfs_blkdev_issue_flush(ip->i_mount->m_ddev_targp);
1163
1164                 /*
1165                  * If this inode is on the RT dev we need to flush that
1166                  * cache as well.
1167                  */
1168                 if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME)
1169                         xfs_blkdev_issue_flush(ip->i_mount->m_rtdev_targp);
1170         }
1171
1172         return error;
1173 }
1174
1175 /*
1176  * This is called by xfs_inactive to free any blocks beyond eof
1177  * when the link count isn't zero and by xfs_dm_punch_hole() when
1178  * punching a hole to EOF.
1179  */
1180 int
1181 xfs_free_eofblocks(
1182         xfs_mount_t     *mp,
1183         xfs_inode_t     *ip,
1184         int             flags)
1185 {
1186         xfs_trans_t     *tp;
1187         int             error;
1188         xfs_fileoff_t   end_fsb;
1189         xfs_fileoff_t   last_fsb;
1190         xfs_filblks_t   map_len;
1191         int             nimaps;
1192         xfs_bmbt_irec_t imap;
1193         int             use_iolock = (flags & XFS_FREE_EOF_LOCK);
1194
1195         /*
1196          * Figure out if there are any blocks beyond the end
1197          * of the file.  If not, then there is nothing to do.
1198          */
1199         end_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)ip->i_size));
1200         last_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1201         map_len = last_fsb - end_fsb;
1202         if (map_len <= 0)
1203                 return 0;
1204
1205         nimaps = 1;
1206         xfs_ilock(ip, XFS_ILOCK_SHARED);
1207         error = XFS_BMAPI(mp, NULL, &ip->i_iocore, end_fsb, map_len, 0,
1208                           NULL, 0, &imap, &nimaps, NULL, NULL);
1209         xfs_iunlock(ip, XFS_ILOCK_SHARED);
1210
1211         if (!error && (nimaps != 0) &&
1212             (imap.br_startblock != HOLESTARTBLOCK ||
1213              ip->i_delayed_blks)) {
1214                 /*
1215                  * Attach the dquots to the inode up front.
1216                  */
1217                 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
1218                         return error;
1219
1220                 /*
1221                  * There are blocks after the end of file.
1222                  * Free them up now by truncating the file to
1223                  * its current size.
1224                  */
1225                 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1226
1227                 /*
1228                  * Do the xfs_itruncate_start() call before
1229                  * reserving any log space because
1230                  * itruncate_start will call into the buffer
1231                  * cache and we can't
1232                  * do that within a transaction.
1233                  */
1234                 if (use_iolock)
1235                         xfs_ilock(ip, XFS_IOLOCK_EXCL);
1236                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
1237                                     ip->i_size);
1238                 if (error) {
1239                         xfs_trans_cancel(tp, 0);
1240                         if (use_iolock)
1241                                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1242                         return error;
1243                 }
1244
1245                 error = xfs_trans_reserve(tp, 0,
1246                                           XFS_ITRUNCATE_LOG_RES(mp),
1247                                           0, XFS_TRANS_PERM_LOG_RES,
1248                                           XFS_ITRUNCATE_LOG_COUNT);
1249                 if (error) {
1250                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1251                         xfs_trans_cancel(tp, 0);
1252                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1253                         return error;
1254                 }
1255
1256                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1257                 xfs_trans_ijoin(tp, ip,
1258                                 XFS_IOLOCK_EXCL |
1259                                 XFS_ILOCK_EXCL);
1260                 xfs_trans_ihold(tp, ip);
1261
1262                 error = xfs_itruncate_finish(&tp, ip,
1263                                              ip->i_size,
1264                                              XFS_DATA_FORK,
1265                                              0);
1266                 /*
1267                  * If we get an error at this point we
1268                  * simply don't bother truncating the file.
1269                  */
1270                 if (error) {
1271                         xfs_trans_cancel(tp,
1272                                          (XFS_TRANS_RELEASE_LOG_RES |
1273                                           XFS_TRANS_ABORT));
1274                 } else {
1275                         error = xfs_trans_commit(tp,
1276                                                 XFS_TRANS_RELEASE_LOG_RES);
1277                 }
1278                 xfs_iunlock(ip, (use_iolock ? (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)
1279                                             : XFS_ILOCK_EXCL));
1280         }
1281         return error;
1282 }
1283
1284 /*
1285  * Free a symlink that has blocks associated with it.
1286  */
1287 STATIC int
1288 xfs_inactive_symlink_rmt(
1289         xfs_inode_t     *ip,
1290         xfs_trans_t     **tpp)
1291 {
1292         xfs_buf_t       *bp;
1293         int             committed;
1294         int             done;
1295         int             error;
1296         xfs_fsblock_t   first_block;
1297         xfs_bmap_free_t free_list;
1298         int             i;
1299         xfs_mount_t     *mp;
1300         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
1301         int             nmaps;
1302         xfs_trans_t     *ntp;
1303         int             size;
1304         xfs_trans_t     *tp;
1305
1306         tp = *tpp;
1307         mp = ip->i_mount;
1308         ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
1309         /*
1310          * We're freeing a symlink that has some
1311          * blocks allocated to it.  Free the
1312          * blocks here.  We know that we've got
1313          * either 1 or 2 extents and that we can
1314          * free them all in one bunmapi call.
1315          */
1316         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
1317         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1318                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1319                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1320                 xfs_trans_cancel(tp, 0);
1321                 *tpp = NULL;
1322                 return error;
1323         }
1324         /*
1325          * Lock the inode, fix the size, and join it to the transaction.
1326          * Hold it so in the normal path, we still have it locked for
1327          * the second transaction.  In the error paths we need it
1328          * held so the cancel won't rele it, see below.
1329          */
1330         xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1331         size = (int)ip->i_d.di_size;
1332         ip->i_d.di_size = 0;
1333         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1334         xfs_trans_ihold(tp, ip);
1335         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1336         /*
1337          * Find the block(s) so we can inval and unmap them.
1338          */
1339         done = 0;
1340         XFS_BMAP_INIT(&free_list, &first_block);
1341         nmaps = ARRAY_SIZE(mval);
1342         if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
1343                         XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
1344                         &free_list, NULL)))
1345                 goto error0;
1346         /*
1347          * Invalidate the block(s).
1348          */
1349         for (i = 0; i < nmaps; i++) {
1350                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
1351                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
1352                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
1353                 xfs_trans_binval(tp, bp);
1354         }
1355         /*
1356          * Unmap the dead block(s) to the free_list.
1357          */
1358         if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
1359                         &first_block, &free_list, NULL, &done)))
1360                 goto error1;
1361         ASSERT(done);
1362         /*
1363          * Commit the first transaction.  This logs the EFI and the inode.
1364          */
1365         if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
1366                 goto error1;
1367         /*
1368          * The transaction must have been committed, since there were
1369          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
1370          * The new tp has the extent freeing and EFDs.
1371          */
1372         ASSERT(committed);
1373         /*
1374          * The first xact was committed, so add the inode to the new one.
1375          * Mark it dirty so it will be logged and moved forward in the log as
1376          * part of every commit.
1377          */
1378         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1379         xfs_trans_ihold(tp, ip);
1380         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1381         /*
1382          * Get a new, empty transaction to return to our caller.
1383          */
1384         ntp = xfs_trans_dup(tp);
1385         /*
1386          * Commit the transaction containing extent freeing and EFDs.
1387          * If we get an error on the commit here or on the reserve below,
1388          * we need to unlock the inode since the new transaction doesn't
1389          * have the inode attached.
1390          */
1391         error = xfs_trans_commit(tp, 0);
1392         tp = ntp;
1393         if (error) {
1394                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1395                 goto error0;
1396         }
1397         /*
1398          * Remove the memory for extent descriptions (just bookkeeping).
1399          */
1400         if (ip->i_df.if_bytes)
1401                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
1402         ASSERT(ip->i_df.if_bytes == 0);
1403         /*
1404          * Put an itruncate log reservation in the new transaction
1405          * for our caller.
1406          */
1407         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1408                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1409                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1410                 goto error0;
1411         }
1412         /*
1413          * Return with the inode locked but not joined to the transaction.
1414          */
1415         *tpp = tp;
1416         return 0;
1417
1418  error1:
1419         xfs_bmap_cancel(&free_list);
1420  error0:
1421         /*
1422          * Have to come here with the inode locked and either
1423          * (held and in the transaction) or (not in the transaction).
1424          * If the inode isn't held then cancel would iput it, but
1425          * that's wrong since this is inactive and the vnode ref
1426          * count is 0 already.
1427          * Cancel won't do anything to the inode if held, but it still
1428          * needs to be locked until the cancel is done, if it was
1429          * joined to the transaction.
1430          */
1431         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1432         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1433         *tpp = NULL;
1434         return error;
1435
1436 }
1437
1438 STATIC int
1439 xfs_inactive_symlink_local(
1440         xfs_inode_t     *ip,
1441         xfs_trans_t     **tpp)
1442 {
1443         int             error;
1444
1445         ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
1446         /*
1447          * We're freeing a symlink which fit into
1448          * the inode.  Just free the memory used
1449          * to hold the old symlink.
1450          */
1451         error = xfs_trans_reserve(*tpp, 0,
1452                                   XFS_ITRUNCATE_LOG_RES(ip->i_mount),
1453                                   0, XFS_TRANS_PERM_LOG_RES,
1454                                   XFS_ITRUNCATE_LOG_COUNT);
1455
1456         if (error) {
1457                 xfs_trans_cancel(*tpp, 0);
1458                 *tpp = NULL;
1459                 return error;
1460         }
1461         xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1462
1463         /*
1464          * Zero length symlinks _can_ exist.
1465          */
1466         if (ip->i_df.if_bytes > 0) {
1467                 xfs_idata_realloc(ip,
1468                                   -(ip->i_df.if_bytes),
1469                                   XFS_DATA_FORK);
1470                 ASSERT(ip->i_df.if_bytes == 0);
1471         }
1472         return 0;
1473 }
1474
1475 STATIC int
1476 xfs_inactive_attrs(
1477         xfs_inode_t     *ip,
1478         xfs_trans_t     **tpp)
1479 {
1480         xfs_trans_t     *tp;
1481         int             error;
1482         xfs_mount_t     *mp;
1483
1484         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
1485         tp = *tpp;
1486         mp = ip->i_mount;
1487         ASSERT(ip->i_d.di_forkoff != 0);
1488         xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1489         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1490
1491         error = xfs_attr_inactive(ip);
1492         if (error) {
1493                 *tpp = NULL;
1494                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1495                 return error; /* goto out */
1496         }
1497
1498         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1499         error = xfs_trans_reserve(tp, 0,
1500                                   XFS_IFREE_LOG_RES(mp),
1501                                   0, XFS_TRANS_PERM_LOG_RES,
1502                                   XFS_INACTIVE_LOG_COUNT);
1503         if (error) {
1504                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1505                 xfs_trans_cancel(tp, 0);
1506                 *tpp = NULL;
1507                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1508                 return error;
1509         }
1510
1511         xfs_ilock(ip, XFS_ILOCK_EXCL);
1512         xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1513         xfs_trans_ihold(tp, ip);
1514         xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1515
1516         ASSERT(ip->i_d.di_anextents == 0);
1517
1518         *tpp = tp;
1519         return 0;
1520 }
1521
1522 STATIC int
1523 xfs_release(
1524         bhv_desc_t      *bdp)
1525 {
1526         xfs_inode_t     *ip;
1527         bhv_vnode_t     *vp;
1528         xfs_mount_t     *mp;
1529         int             error;
1530
1531         vp = BHV_TO_VNODE(bdp);
1532         ip = XFS_BHVTOI(bdp);
1533         mp = ip->i_mount;
1534
1535         if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0))
1536                 return 0;
1537
1538         /* If this is a read-only mount, don't do this (would generate I/O) */
1539         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1540                 return 0;
1541
1542         if (!XFS_FORCED_SHUTDOWN(mp)) {
1543                 /*
1544                  * If we are using filestreams, and we have an unlinked
1545                  * file that we are processing the last close on, then nothing
1546                  * will be able to reopen and write to this file. Purge this
1547                  * inode from the filestreams cache so that it doesn't delay
1548                  * teardown of the inode.
1549                  */
1550                 if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
1551                         xfs_filestream_deassociate(ip);
1552
1553                 /*
1554                  * If we previously truncated this file and removed old data
1555                  * in the process, we want to initiate "early" writeout on
1556                  * the last close.  This is an attempt to combat the notorious
1557                  * NULL files problem which is particularly noticable from a
1558                  * truncate down, buffered (re-)write (delalloc), followed by
1559                  * a crash.  What we are effectively doing here is
1560                  * significantly reducing the time window where we'd otherwise
1561                  * be exposed to that problem.
1562                  */
1563                 if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
1564                         bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
1565         }
1566
1567 #ifdef HAVE_REFCACHE
1568         /* If we are in the NFS reference cache then don't do this now */
1569         if (ip->i_refcache)
1570                 return 0;
1571 #endif
1572
1573         if (ip->i_d.di_nlink != 0) {
1574                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1575                      ((ip->i_size > 0) || (VN_CACHED(vp) > 0 ||
1576                        ip->i_delayed_blks > 0)) &&
1577                      (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
1578                     (!(ip->i_d.di_flags &
1579                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
1580                         error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
1581                         if (error)
1582                                 return error;
1583                         /* Update linux inode block count after free above */
1584                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1585                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1586                 }
1587         }
1588
1589         return 0;
1590 }
1591
1592 /*
1593  * xfs_inactive
1594  *
1595  * This is called when the vnode reference count for the vnode
1596  * goes to zero.  If the file has been unlinked, then it must
1597  * now be truncated.  Also, we clear all of the read-ahead state
1598  * kept for the inode here since the file is now closed.
1599  */
1600 STATIC int
1601 xfs_inactive(
1602         bhv_desc_t      *bdp,
1603         cred_t          *credp)
1604 {
1605         xfs_inode_t     *ip;
1606         bhv_vnode_t     *vp;
1607         xfs_bmap_free_t free_list;
1608         xfs_fsblock_t   first_block;
1609         int             committed;
1610         xfs_trans_t     *tp;
1611         xfs_mount_t     *mp;
1612         int             error;
1613         int             truncate;
1614
1615         vp = BHV_TO_VNODE(bdp);
1616         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
1617
1618         ip = XFS_BHVTOI(bdp);
1619
1620         /*
1621          * If the inode is already free, then there can be nothing
1622          * to clean up here.
1623          */
1624         if (ip->i_d.di_mode == 0 || VN_BAD(vp)) {
1625                 ASSERT(ip->i_df.if_real_bytes == 0);
1626                 ASSERT(ip->i_df.if_broot_bytes == 0);
1627                 return VN_INACTIVE_CACHE;
1628         }
1629
1630         /*
1631          * Only do a truncate if it's a regular file with
1632          * some actual space in it.  It's OK to look at the
1633          * inode's fields without the lock because we're the
1634          * only one with a reference to the inode.
1635          */
1636         truncate = ((ip->i_d.di_nlink == 0) &&
1637             ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
1638              (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
1639             ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
1640
1641         mp = ip->i_mount;
1642
1643         if (ip->i_d.di_nlink == 0 &&
1644             DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_DESTROY)) {
1645                 (void) XFS_SEND_DESTROY(mp, vp, DM_RIGHT_NULL);
1646         }
1647
1648         error = 0;
1649
1650         /* If this is a read-only mount, don't do this (would generate I/O) */
1651         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
1652                 goto out;
1653
1654         if (ip->i_d.di_nlink != 0) {
1655                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
1656                      ((ip->i_size > 0) || (VN_CACHED(vp) > 0 ||
1657                        ip->i_delayed_blks > 0)) &&
1658                       (ip->i_df.if_flags & XFS_IFEXTENTS) &&
1659                      (!(ip->i_d.di_flags &
1660                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
1661                       (ip->i_delayed_blks != 0)))) {
1662                         error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
1663                         if (error)
1664                                 return VN_INACTIVE_CACHE;
1665                         /* Update linux inode block count after free above */
1666                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
1667                                 ip->i_d.di_nblocks + ip->i_delayed_blks);
1668                 }
1669                 goto out;
1670         }
1671
1672         ASSERT(ip->i_d.di_nlink == 0);
1673
1674         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
1675                 return VN_INACTIVE_CACHE;
1676
1677         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1678         if (truncate) {
1679                 /*
1680                  * Do the xfs_itruncate_start() call before
1681                  * reserving any log space because itruncate_start
1682                  * will call into the buffer cache and we can't
1683                  * do that within a transaction.
1684                  */
1685                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1686
1687                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
1688                 if (error) {
1689                         xfs_trans_cancel(tp, 0);
1690                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1691                         return VN_INACTIVE_CACHE;
1692                 }
1693
1694                 error = xfs_trans_reserve(tp, 0,
1695                                           XFS_ITRUNCATE_LOG_RES(mp),
1696                                           0, XFS_TRANS_PERM_LOG_RES,
1697                                           XFS_ITRUNCATE_LOG_COUNT);
1698                 if (error) {
1699                         /* Don't call itruncate_cleanup */
1700                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1701                         xfs_trans_cancel(tp, 0);
1702                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1703                         return VN_INACTIVE_CACHE;
1704                 }
1705
1706                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1707                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1708                 xfs_trans_ihold(tp, ip);
1709
1710                 /*
1711                  * normally, we have to run xfs_itruncate_finish sync.
1712                  * But if filesystem is wsync and we're in the inactive
1713                  * path, then we know that nlink == 0, and that the
1714                  * xaction that made nlink == 0 is permanently committed
1715                  * since xfs_remove runs as a synchronous transaction.
1716                  */
1717                 error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK,
1718                                 (!(mp->m_flags & XFS_MOUNT_WSYNC) ? 1 : 0));
1719
1720                 if (error) {
1721                         xfs_trans_cancel(tp,
1722                                 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1723                         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1724                         return VN_INACTIVE_CACHE;
1725                 }
1726         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
1727
1728                 /*
1729                  * If we get an error while cleaning up a
1730                  * symlink we bail out.
1731                  */
1732                 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
1733                         xfs_inactive_symlink_rmt(ip, &tp) :
1734                         xfs_inactive_symlink_local(ip, &tp);
1735
1736                 if (error) {
1737                         ASSERT(tp == NULL);
1738                         return VN_INACTIVE_CACHE;
1739                 }
1740
1741                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1742                 xfs_trans_ihold(tp, ip);
1743         } else {
1744                 error = xfs_trans_reserve(tp, 0,
1745                                           XFS_IFREE_LOG_RES(mp),
1746                                           0, XFS_TRANS_PERM_LOG_RES,
1747                                           XFS_INACTIVE_LOG_COUNT);
1748                 if (error) {
1749                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1750                         xfs_trans_cancel(tp, 0);
1751                         return VN_INACTIVE_CACHE;
1752                 }
1753
1754                 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1755                 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1756                 xfs_trans_ihold(tp, ip);
1757         }
1758
1759         /*
1760          * If there are attributes associated with the file
1761          * then blow them away now.  The code calls a routine
1762          * that recursively deconstructs the attribute fork.
1763          * We need to just commit the current transaction
1764          * because we can't use it for xfs_attr_inactive().
1765          */
1766         if (ip->i_d.di_anextents > 0) {
1767                 error = xfs_inactive_attrs(ip, &tp);
1768                 /*
1769                  * If we got an error, the transaction is already
1770                  * cancelled, and the inode is unlocked. Just get out.
1771                  */
1772                  if (error)
1773                          return VN_INACTIVE_CACHE;
1774         } else if (ip->i_afp) {
1775                 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1776         }
1777
1778         /*
1779          * Free the inode.
1780          */
1781         XFS_BMAP_INIT(&free_list, &first_block);
1782         error = xfs_ifree(tp, ip, &free_list);
1783         if (error) {
1784                 /*
1785                  * If we fail to free the inode, shut down.  The cancel
1786                  * might do that, we need to make sure.  Otherwise the
1787                  * inode might be lost for a long time or forever.
1788                  */
1789                 if (!XFS_FORCED_SHUTDOWN(mp)) {
1790                         cmn_err(CE_NOTE,
1791                 "xfs_inactive:  xfs_ifree() returned an error = %d on %s",
1792                                 error, mp->m_fsname);
1793                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1794                 }
1795                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
1796         } else {
1797                 /*
1798                  * Credit the quota account(s). The inode is gone.
1799                  */
1800                 XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1801
1802                 /*
1803                  * Just ignore errors at this point.  There is
1804                  * nothing we can do except to try to keep going.
1805                  */
1806                 (void) xfs_bmap_finish(&tp,  &free_list, &committed);
1807                 (void) xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1808         }
1809         /*
1810          * Release the dquots held by inode, if any.
1811          */
1812         XFS_QM_DQDETACH(mp, ip);
1813
1814         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1815
1816  out:
1817         return VN_INACTIVE_CACHE;
1818 }
1819
1820
1821 /*
1822  * xfs_lookup
1823  */
1824 STATIC int
1825 xfs_lookup(
1826         bhv_desc_t              *dir_bdp,
1827         bhv_vname_t             *dentry,
1828         bhv_vnode_t             **vpp,
1829         int                     flags,
1830         bhv_vnode_t             *rdir,
1831         cred_t                  *credp)
1832 {
1833         xfs_inode_t             *dp, *ip;
1834         xfs_ino_t               e_inum;
1835         int                     error;
1836         uint                    lock_mode;
1837         bhv_vnode_t             *dir_vp;
1838
1839         dir_vp = BHV_TO_VNODE(dir_bdp);
1840         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1841
1842         dp = XFS_BHVTOI(dir_bdp);
1843
1844         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
1845                 return XFS_ERROR(EIO);
1846
1847         lock_mode = xfs_ilock_map_shared(dp);
1848         error = xfs_dir_lookup_int(dir_bdp, lock_mode, dentry, &e_inum, &ip);
1849         if (!error) {
1850                 *vpp = XFS_ITOV(ip);
1851                 ITRACE(ip);
1852         }
1853         xfs_iunlock_map_shared(dp, lock_mode);
1854         return error;
1855 }
1856
1857
1858 /*
1859  * xfs_create (create a new file).
1860  */
1861 STATIC int
1862 xfs_create(
1863         bhv_desc_t              *dir_bdp,
1864         bhv_vname_t             *dentry,
1865         bhv_vattr_t             *vap,
1866         bhv_vnode_t             **vpp,
1867         cred_t                  *credp)
1868 {
1869         char                    *name = VNAME(dentry);
1870         bhv_vnode_t             *dir_vp;
1871         xfs_inode_t             *dp, *ip;
1872         bhv_vnode_t             *vp = NULL;
1873         xfs_trans_t             *tp;
1874         xfs_mount_t             *mp;
1875         xfs_dev_t               rdev;
1876         int                     error;
1877         xfs_bmap_free_t         free_list;
1878         xfs_fsblock_t           first_block;
1879         boolean_t               dp_joined_to_trans;
1880         int                     dm_event_sent = 0;
1881         uint                    cancel_flags;
1882         int                     committed;
1883         xfs_prid_t              prid;
1884         struct xfs_dquot        *udqp, *gdqp;
1885         uint                    resblks;
1886         int                     dm_di_mode;
1887         int                     namelen;
1888
1889         ASSERT(!*vpp);
1890         dir_vp = BHV_TO_VNODE(dir_bdp);
1891         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
1892
1893         dp = XFS_BHVTOI(dir_bdp);
1894         mp = dp->i_mount;
1895
1896         dm_di_mode = vap->va_mode;
1897         namelen = VNAMELEN(dentry);
1898
1899         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
1900                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
1901                                 dir_vp, DM_RIGHT_NULL, NULL,
1902                                 DM_RIGHT_NULL, name, NULL,
1903                                 dm_di_mode, 0, 0);
1904
1905                 if (error)
1906                         return error;
1907                 dm_event_sent = 1;
1908         }
1909
1910         if (XFS_FORCED_SHUTDOWN(mp))
1911                 return XFS_ERROR(EIO);
1912
1913         /* Return through std_return after this point. */
1914
1915         udqp = gdqp = NULL;
1916         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1917                 prid = dp->i_d.di_projid;
1918         else if (vap->va_mask & XFS_AT_PROJID)
1919                 prid = (xfs_prid_t)vap->va_projid;
1920         else
1921                 prid = (xfs_prid_t)dfltprid;
1922
1923         /*
1924          * Make sure that we have allocated dquot(s) on disk.
1925          */
1926         error = XFS_QM_DQVOPALLOC(mp, dp,
1927                         current_fsuid(credp), current_fsgid(credp), prid,
1928                         XFS_QMOPT_QUOTALL|XFS_QMOPT_INHERIT, &udqp, &gdqp);
1929         if (error)
1930                 goto std_return;
1931
1932         ip = NULL;
1933         dp_joined_to_trans = B_FALSE;
1934
1935         tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
1936         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1937         resblks = XFS_CREATE_SPACE_RES(mp, namelen);
1938         /*
1939          * Initially assume that the file does not exist and
1940          * reserve the resources for that case.  If that is not
1941          * the case we'll drop the one we have and get a more
1942          * appropriate transaction later.
1943          */
1944         error = xfs_trans_reserve(tp, resblks, XFS_CREATE_LOG_RES(mp), 0,
1945                         XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1946         if (error == ENOSPC) {
1947                 resblks = 0;
1948                 error = xfs_trans_reserve(tp, 0, XFS_CREATE_LOG_RES(mp), 0,
1949                                 XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1950         }
1951         if (error) {
1952                 cancel_flags = 0;
1953                 dp = NULL;
1954                 goto error_return;
1955         }
1956
1957         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1958
1959         XFS_BMAP_INIT(&free_list, &first_block);
1960
1961         ASSERT(ip == NULL);
1962
1963         /*
1964          * Reserve disk quota and the inode.
1965          */
1966         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
1967         if (error)
1968                 goto error_return;
1969
1970         if (resblks == 0 && (error = xfs_dir_canenter(tp, dp, name, namelen)))
1971                 goto error_return;
1972         rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
1973         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
1974                         rdev, credp, prid, resblks > 0,
1975                         &ip, &committed);
1976         if (error) {
1977                 if (error == ENOSPC)
1978                         goto error_return;
1979                 goto abort_return;
1980         }
1981         ITRACE(ip);
1982
1983         /*
1984          * At this point, we've gotten a newly allocated inode.
1985          * It is locked (and joined to the transaction).
1986          */
1987
1988         ASSERT(ismrlocked (&ip->i_lock, MR_UPDATE));
1989
1990         /*
1991          * Now we join the directory inode to the transaction.
1992          * We do not do it earlier because xfs_dir_ialloc
1993          * might commit the previous transaction (and release
1994          * all the locks).
1995          */
1996
1997         VN_HOLD(dir_vp);
1998         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1999         dp_joined_to_trans = B_TRUE;
2000
2001         error = xfs_dir_createname(tp, dp, name, namelen, ip->i_ino,
2002                                         &first_block, &free_list, resblks ?
2003                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
2004         if (error) {
2005                 ASSERT(error != ENOSPC);
2006                 goto abort_return;
2007         }
2008         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2009         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2010
2011         /*
2012          * If this is a synchronous mount, make sure that the
2013          * create transaction goes to disk before returning to
2014          * the user.
2015          */
2016         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2017                 xfs_trans_set_sync(tp);
2018         }
2019
2020         dp->i_gen++;
2021
2022         /*
2023          * Attach the dquot(s) to the inodes and modify them incore.
2024          * These ids of the inode couldn't have changed since the new
2025          * inode has been locked ever since it was created.
2026          */
2027         XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
2028
2029         /*
2030          * xfs_trans_commit normally decrements the vnode ref count
2031          * when it unlocks the inode. Since we want to return the
2032          * vnode to the caller, we bump the vnode ref count now.
2033          */
2034         IHOLD(ip);
2035         vp = XFS_ITOV(ip);
2036
2037         error = xfs_bmap_finish(&tp, &free_list, &committed);
2038         if (error) {
2039                 xfs_bmap_cancel(&free_list);
2040                 goto abort_rele;
2041         }
2042
2043         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2044         if (error) {
2045                 IRELE(ip);
2046                 tp = NULL;
2047                 goto error_return;
2048         }
2049
2050         XFS_QM_DQRELE(mp, udqp);
2051         XFS_QM_DQRELE(mp, gdqp);
2052
2053         /*
2054          * Propagate the fact that the vnode changed after the
2055          * xfs_inode locks have been released.
2056          */
2057         bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
2058
2059         *vpp = vp;
2060
2061         /* Fallthrough to std_return with error = 0  */
2062
2063 std_return:
2064         if ( (*vpp || (error != 0 && dm_event_sent != 0)) &&
2065                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2066                                                         DM_EVENT_POSTCREATE)) {
2067                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2068                         dir_vp, DM_RIGHT_NULL,
2069                         *vpp ? vp:NULL,
2070                         DM_RIGHT_NULL, name, NULL,
2071                         dm_di_mode, error, 0);
2072         }
2073         return error;
2074
2075  abort_return:
2076         cancel_flags |= XFS_TRANS_ABORT;
2077         /* FALLTHROUGH */
2078
2079  error_return:
2080         if (tp != NULL)
2081                 xfs_trans_cancel(tp, cancel_flags);
2082
2083         if (!dp_joined_to_trans && (dp != NULL))
2084                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2085         XFS_QM_DQRELE(mp, udqp);
2086         XFS_QM_DQRELE(mp, gdqp);
2087
2088         goto std_return;
2089
2090  abort_rele:
2091         /*
2092          * Wait until after the current transaction is aborted to
2093          * release the inode.  This prevents recursive transactions
2094          * and deadlocks from xfs_inactive.
2095          */
2096         cancel_flags |= XFS_TRANS_ABORT;
2097         xfs_trans_cancel(tp, cancel_flags);
2098         IRELE(ip);
2099
2100         XFS_QM_DQRELE(mp, udqp);
2101         XFS_QM_DQRELE(mp, gdqp);
2102
2103         goto std_return;
2104 }
2105
2106 #ifdef DEBUG
2107 /*
2108  * Some counters to see if (and how often) we are hitting some deadlock
2109  * prevention code paths.
2110  */
2111
2112 int xfs_rm_locks;
2113 int xfs_rm_lock_delays;
2114 int xfs_rm_attempts;
2115 #endif
2116
2117 /*
2118  * The following routine will lock the inodes associated with the
2119  * directory and the named entry in the directory. The locks are
2120  * acquired in increasing inode number.
2121  *
2122  * If the entry is "..", then only the directory is locked. The
2123  * vnode ref count will still include that from the .. entry in
2124  * this case.
2125  *
2126  * There is a deadlock we need to worry about. If the locked directory is
2127  * in the AIL, it might be blocking up the log. The next inode we lock
2128  * could be already locked by another thread waiting for log space (e.g
2129  * a permanent log reservation with a long running transaction (see
2130  * xfs_itruncate_finish)). To solve this, we must check if the directory
2131  * is in the ail and use lock_nowait. If we can't lock, we need to
2132  * drop the inode lock on the directory and try again. xfs_iunlock will
2133  * potentially push the tail if we were holding up the log.
2134  */
2135 STATIC int
2136 xfs_lock_dir_and_entry(
2137         xfs_inode_t     *dp,
2138         xfs_inode_t     *ip)    /* inode of entry 'name' */
2139 {
2140         int             attempts;
2141         xfs_ino_t       e_inum;
2142         xfs_inode_t     *ips[2];
2143         xfs_log_item_t  *lp;
2144
2145 #ifdef DEBUG
2146         xfs_rm_locks++;
2147 #endif
2148         attempts = 0;
2149
2150 again:
2151         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
2152
2153         e_inum = ip->i_ino;
2154
2155         ITRACE(ip);
2156
2157         /*
2158          * We want to lock in increasing inum. Since we've already
2159          * acquired the lock on the directory, we may need to release
2160          * if if the inum of the entry turns out to be less.
2161          */
2162         if (e_inum > dp->i_ino) {
2163                 /*
2164                  * We are already in the right order, so just
2165                  * lock on the inode of the entry.
2166                  * We need to use nowait if dp is in the AIL.
2167                  */
2168
2169                 lp = (xfs_log_item_t *)dp->i_itemp;
2170                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2171                         if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2172                                 attempts++;
2173 #ifdef DEBUG
2174                                 xfs_rm_attempts++;
2175 #endif
2176
2177                                 /*
2178                                  * Unlock dp and try again.
2179                                  * xfs_iunlock will try to push the tail
2180                                  * if the inode is in the AIL.
2181                                  */
2182
2183                                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2184
2185                                 if ((attempts % 5) == 0) {
2186                                         delay(1); /* Don't just spin the CPU */
2187 #ifdef DEBUG
2188                                         xfs_rm_lock_delays++;
2189 #endif
2190                                 }
2191                                 goto again;
2192                         }
2193                 } else {
2194                         xfs_ilock(ip, XFS_ILOCK_EXCL);
2195                 }
2196         } else if (e_inum < dp->i_ino) {
2197                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
2198
2199                 ips[0] = ip;
2200                 ips[1] = dp;
2201                 xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2202         }
2203         /* else  e_inum == dp->i_ino */
2204         /*     This can happen if we're asked to lock /x/..
2205          *     the entry is "..", which is also the parent directory.
2206          */
2207
2208         return 0;
2209 }
2210
2211 #ifdef DEBUG
2212 int xfs_locked_n;
2213 int xfs_small_retries;
2214 int xfs_middle_retries;
2215 int xfs_lots_retries;
2216 int xfs_lock_delays;
2217 #endif
2218
2219 /*
2220  * Bump the subclass so xfs_lock_inodes() acquires each lock with
2221  * a different value
2222  */
2223 static inline int
2224 xfs_lock_inumorder(int lock_mode, int subclass)
2225 {
2226         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
2227                 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
2228         if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
2229                 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
2230
2231         return lock_mode;
2232 }
2233
2234 /*
2235  * The following routine will lock n inodes in exclusive mode.
2236  * We assume the caller calls us with the inodes in i_ino order.
2237  *
2238  * We need to detect deadlock where an inode that we lock
2239  * is in the AIL and we start waiting for another inode that is locked
2240  * by a thread in a long running transaction (such as truncate). This can
2241  * result in deadlock since the long running trans might need to wait
2242  * for the inode we just locked in order to push the tail and free space
2243  * in the log.
2244  */
2245 void
2246 xfs_lock_inodes(
2247         xfs_inode_t     **ips,
2248         int             inodes,
2249         int             first_locked,
2250         uint            lock_mode)
2251 {
2252         int             attempts = 0, i, j, try_lock;
2253         xfs_log_item_t  *lp;
2254
2255         ASSERT(ips && (inodes >= 2)); /* we need at least two */
2256
2257         if (first_locked) {
2258                 try_lock = 1;
2259                 i = 1;
2260         } else {
2261                 try_lock = 0;
2262                 i = 0;
2263         }
2264
2265 again:
2266         for (; i < inodes; i++) {
2267                 ASSERT(ips[i]);
2268
2269                 if (i && (ips[i] == ips[i-1]))  /* Already locked */
2270                         continue;
2271
2272                 /*
2273                  * If try_lock is not set yet, make sure all locked inodes
2274                  * are not in the AIL.
2275                  * If any are, set try_lock to be used later.
2276                  */
2277
2278                 if (!try_lock) {
2279                         for (j = (i - 1); j >= 0 && !try_lock; j--) {
2280                                 lp = (xfs_log_item_t *)ips[j]->i_itemp;
2281                                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
2282                                         try_lock++;
2283                                 }
2284                         }
2285                 }
2286
2287                 /*
2288                  * If any of the previous locks we have locked is in the AIL,
2289                  * we must TRY to get the second and subsequent locks. If
2290                  * we can't get any, we must release all we have
2291                  * and try again.
2292                  */
2293
2294                 if (try_lock) {
2295                         /* try_lock must be 0 if i is 0. */
2296                         /*
2297                          * try_lock means we have an inode locked
2298                          * that is in the AIL.
2299                          */
2300                         ASSERT(i != 0);
2301                         if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
2302                                 attempts++;
2303
2304                                 /*
2305                                  * Unlock all previous guys and try again.
2306                                  * xfs_iunlock will try to push the tail
2307                                  * if the inode is in the AIL.
2308                                  */
2309
2310                                 for(j = i - 1; j >= 0; j--) {
2311
2312                                         /*
2313                                          * Check to see if we've already
2314                                          * unlocked this one.
2315                                          * Not the first one going back,
2316                                          * and the inode ptr is the same.
2317                                          */
2318                                         if ((j != (i - 1)) && ips[j] ==
2319                                                                 ips[j+1])
2320                                                 continue;
2321
2322                                         xfs_iunlock(ips[j], lock_mode);
2323                                 }
2324
2325                                 if ((attempts % 5) == 0) {
2326                                         delay(1); /* Don't just spin the CPU */
2327 #ifdef DEBUG
2328                                         xfs_lock_delays++;
2329 #endif
2330                                 }
2331                                 i = 0;
2332                                 try_lock = 0;
2333                                 goto again;
2334                         }
2335                 } else {
2336                         xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
2337                 }
2338         }
2339
2340 #ifdef DEBUG
2341         if (attempts) {
2342                 if (attempts < 5) xfs_small_retries++;
2343                 else if (attempts < 100) xfs_middle_retries++;
2344                 else xfs_lots_retries++;
2345         } else {
2346                 xfs_locked_n++;
2347         }
2348 #endif
2349 }
2350
2351 #ifdef  DEBUG
2352 #define REMOVE_DEBUG_TRACE(x)   {remove_which_error_return = (x);}
2353 int remove_which_error_return = 0;
2354 #else /* ! DEBUG */
2355 #define REMOVE_DEBUG_TRACE(x)
2356 #endif  /* ! DEBUG */
2357
2358
2359 /*
2360  * xfs_remove
2361  *
2362  */
2363 STATIC int
2364 xfs_remove(
2365         bhv_desc_t              *dir_bdp,
2366         bhv_vname_t             *dentry,
2367         cred_t                  *credp)
2368 {
2369         bhv_vnode_t             *dir_vp;
2370         char                    *name = VNAME(dentry);
2371         xfs_inode_t             *dp, *ip;
2372         xfs_trans_t             *tp = NULL;
2373         xfs_mount_t             *mp;
2374         int                     error = 0;
2375         xfs_bmap_free_t         free_list;
2376         xfs_fsblock_t           first_block;
2377         int                     cancel_flags;
2378         int                     committed;
2379         int                     dm_di_mode = 0;
2380         int                     link_zero;
2381         uint                    resblks;
2382         int                     namelen;
2383
2384         dir_vp = BHV_TO_VNODE(dir_bdp);
2385         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2386
2387         dp = XFS_BHVTOI(dir_bdp);
2388         mp = dp->i_mount;
2389
2390         if (XFS_FORCED_SHUTDOWN(mp))
2391                 return XFS_ERROR(EIO);
2392
2393         namelen = VNAMELEN(dentry);
2394
2395         if (!xfs_get_dir_entry(dentry, &ip)) {
2396                 dm_di_mode = ip->i_d.di_mode;
2397                 IRELE(ip);
2398         }
2399
2400         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
2401                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE, dir_vp,
2402                                         DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
2403                                         name, NULL, dm_di_mode, 0, 0);
2404                 if (error)
2405                         return error;
2406         }
2407
2408         /* From this point on, return through std_return */
2409         ip = NULL;
2410
2411         /*
2412          * We need to get a reference to ip before we get our log
2413          * reservation. The reason for this is that we cannot call
2414          * xfs_iget for an inode for which we do not have a reference
2415          * once we've acquired a log reservation. This is because the
2416          * inode we are trying to get might be in xfs_inactive going
2417          * for a log reservation. Since we'll have to wait for the
2418          * inactive code to complete before returning from xfs_iget,
2419          * we need to make sure that we don't have log space reserved
2420          * when we call xfs_iget.  Instead we get an unlocked reference
2421          * to the inode before getting our log reservation.
2422          */
2423         error = xfs_get_dir_entry(dentry, &ip);
2424         if (error) {
2425                 REMOVE_DEBUG_TRACE(__LINE__);
2426                 goto std_return;
2427         }
2428
2429         dm_di_mode = ip->i_d.di_mode;
2430
2431         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2432
2433         ITRACE(ip);
2434
2435         error = XFS_QM_DQATTACH(mp, dp, 0);
2436         if (!error && dp != ip)
2437                 error = XFS_QM_DQATTACH(mp, ip, 0);
2438         if (error) {
2439                 REMOVE_DEBUG_TRACE(__LINE__);
2440                 IRELE(ip);
2441                 goto std_return;
2442         }
2443
2444         tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
2445         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2446         /*
2447          * We try to get the real space reservation first,
2448          * allowing for directory btree deletion(s) implying
2449          * possible bmap insert(s).  If we can't get the space
2450          * reservation then we use 0 instead, and avoid the bmap
2451          * btree insert(s) in the directory code by, if the bmap
2452          * insert tries to happen, instead trimming the LAST
2453          * block from the directory.
2454          */
2455         resblks = XFS_REMOVE_SPACE_RES(mp);
2456         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
2457                         XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2458         if (error == ENOSPC) {
2459                 resblks = 0;
2460                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
2461                                 XFS_TRANS_PERM_LOG_RES, XFS_REMOVE_LOG_COUNT);
2462         }
2463         if (error) {
2464                 ASSERT(error != ENOSPC);
2465                 REMOVE_DEBUG_TRACE(__LINE__);
2466                 xfs_trans_cancel(tp, 0);
2467                 IRELE(ip);
2468                 return error;
2469         }
2470
2471         error = xfs_lock_dir_and_entry(dp, ip);
2472         if (error) {
2473                 REMOVE_DEBUG_TRACE(__LINE__);
2474                 xfs_trans_cancel(tp, cancel_flags);
2475                 IRELE(ip);
2476                 goto std_return;
2477         }
2478
2479         /*
2480          * At this point, we've gotten both the directory and the entry
2481          * inodes locked.
2482          */
2483         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2484         if (dp != ip) {
2485                 /*
2486                  * Increment vnode ref count only in this case since
2487                  * there's an extra vnode reference in the case where
2488                  * dp == ip.
2489                  */
2490                 IHOLD(dp);
2491                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2492         }
2493
2494         /*
2495          * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2496          */
2497         XFS_BMAP_INIT(&free_list, &first_block);
2498         error = xfs_dir_removename(tp, dp, name, namelen, ip->i_ino,
2499                                         &first_block, &free_list, 0);
2500         if (error) {
2501                 ASSERT(error != ENOENT);
2502                 REMOVE_DEBUG_TRACE(__LINE__);
2503                 goto error1;
2504         }
2505         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2506
2507         dp->i_gen++;
2508         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2509
2510         error = xfs_droplink(tp, ip);
2511         if (error) {
2512                 REMOVE_DEBUG_TRACE(__LINE__);
2513                 goto error1;
2514         }
2515
2516         /* Determine if this is the last link while
2517          * we are in the transaction.
2518          */
2519         link_zero = (ip)->i_d.di_nlink==0;
2520
2521         /*
2522          * Take an extra ref on the inode so that it doesn't
2523          * go to xfs_inactive() from within the commit.
2524          */
2525         IHOLD(ip);
2526
2527         /*
2528          * If this is a synchronous mount, make sure that the
2529          * remove transaction goes to disk before returning to
2530          * the user.
2531          */
2532         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2533                 xfs_trans_set_sync(tp);
2534         }
2535
2536         error = xfs_bmap_finish(&tp, &free_list, &committed);
2537         if (error) {
2538                 REMOVE_DEBUG_TRACE(__LINE__);
2539                 goto error_rele;
2540         }
2541
2542         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2543         if (error) {
2544                 IRELE(ip);
2545                 goto std_return;
2546         }
2547
2548         /*
2549          * Before we drop our extra reference to the inode, purge it
2550          * from the refcache if it is there.  By waiting until afterwards
2551          * to do the IRELE, we ensure that we won't go inactive in the
2552          * xfs_refcache_purge_ip routine (although that would be OK).
2553          */
2554         xfs_refcache_purge_ip(ip);
2555
2556         /*
2557          * If we are using filestreams, kill the stream association.
2558          * If the file is still open it may get a new one but that
2559          * will get killed on last close in xfs_close() so we don't
2560          * have to worry about that.
2561          */
2562         if (link_zero && xfs_inode_is_filestream(ip))
2563                 xfs_filestream_deassociate(ip);
2564
2565         vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
2566
2567         /*
2568          * Let interposed file systems know about removed links.
2569          */
2570         bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
2571
2572         IRELE(ip);
2573
2574 /*      Fall through to std_return with error = 0 */
2575  std_return:
2576         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp,
2577                                                 DM_EVENT_POSTREMOVE)) {
2578                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
2579                                 dir_vp, DM_RIGHT_NULL,
2580                                 NULL, DM_RIGHT_NULL,
2581                                 name, NULL, dm_di_mode, error, 0);
2582         }
2583         return error;
2584
2585  error1:
2586         xfs_bmap_cancel(&free_list);
2587         cancel_flags |= XFS_TRANS_ABORT;
2588         xfs_trans_cancel(tp, cancel_flags);
2589         goto std_return;
2590
2591  error_rele:
2592         /*
2593          * In this case make sure to not release the inode until after
2594          * the current transaction is aborted.  Releasing it beforehand
2595          * can cause us to go to xfs_inactive and start a recursive
2596          * transaction which can easily deadlock with the current one.
2597          */
2598         xfs_bmap_cancel(&free_list);
2599         cancel_flags |= XFS_TRANS_ABORT;
2600         xfs_trans_cancel(tp, cancel_flags);
2601
2602         /*
2603          * Before we drop our extra reference to the inode, purge it
2604          * from the refcache if it is there.  By waiting until afterwards
2605          * to do the IRELE, we ensure that we won't go inactive in the
2606          * xfs_refcache_purge_ip routine (although that would be OK).
2607          */
2608         xfs_refcache_purge_ip(ip);
2609
2610         IRELE(ip);
2611
2612         goto std_return;
2613 }
2614
2615
2616 /*
2617  * xfs_link
2618  *
2619  */
2620 STATIC int
2621 xfs_link(
2622         bhv_desc_t              *target_dir_bdp,
2623         bhv_vnode_t             *src_vp,
2624         bhv_vname_t             *dentry,
2625         cred_t                  *credp)
2626 {
2627         xfs_inode_t             *tdp, *sip;
2628         xfs_trans_t             *tp;
2629         xfs_mount_t             *mp;
2630         xfs_inode_t             *ips[2];
2631         int                     error;
2632         xfs_bmap_free_t         free_list;
2633         xfs_fsblock_t           first_block;
2634         int                     cancel_flags;
2635         int                     committed;
2636         bhv_vnode_t             *target_dir_vp;
2637         int                     resblks;
2638         char                    *target_name = VNAME(dentry);
2639         int                     target_namelen;
2640
2641         target_dir_vp = BHV_TO_VNODE(target_dir_bdp);
2642         vn_trace_entry(target_dir_vp, __FUNCTION__, (inst_t *)__return_address);
2643         vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address);
2644
2645         target_namelen = VNAMELEN(dentry);
2646         ASSERT(!VN_ISDIR(src_vp));
2647
2648         sip = xfs_vtoi(src_vp);
2649         tdp = XFS_BHVTOI(target_dir_bdp);
2650         mp = tdp->i_mount;
2651         if (XFS_FORCED_SHUTDOWN(mp))
2652                 return XFS_ERROR(EIO);
2653
2654         if (DM_EVENT_ENABLED(src_vp->v_vfsp, tdp, DM_EVENT_LINK)) {
2655                 error = XFS_SEND_NAMESP(mp, DM_EVENT_LINK,
2656                                         target_dir_vp, DM_RIGHT_NULL,
2657                                         src_vp, DM_RIGHT_NULL,
2658                                         target_name, NULL, 0, 0, 0);
2659                 if (error)
2660                         return error;
2661         }
2662
2663         /* Return through std_return after this point. */
2664
2665         error = XFS_QM_DQATTACH(mp, sip, 0);
2666         if (!error && sip != tdp)
2667                 error = XFS_QM_DQATTACH(mp, tdp, 0);
2668         if (error)
2669                 goto std_return;
2670
2671         tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
2672         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2673         resblks = XFS_LINK_SPACE_RES(mp, target_namelen);
2674         error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
2675                         XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2676         if (error == ENOSPC) {
2677                 resblks = 0;
2678                 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
2679                                 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2680         }
2681         if (error) {
2682                 cancel_flags = 0;
2683                 goto error_return;
2684         }
2685
2686         if (sip->i_ino < tdp->i_ino) {
2687                 ips[0] = sip;
2688                 ips[1] = tdp;
2689         } else {
2690                 ips[0] = tdp;
2691                 ips[1] = sip;
2692         }
2693
2694         xfs_lock_inodes(ips, 2, 0, XFS_ILOCK_EXCL);
2695
2696         /*
2697          * Increment vnode ref counts since xfs_trans_commit &
2698          * xfs_trans_cancel will both unlock the inodes and
2699          * decrement the associated ref counts.
2700          */
2701         VN_HOLD(src_vp);
2702         VN_HOLD(target_dir_vp);
2703         xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
2704         xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
2705
2706         /*
2707          * If the source has too many links, we can't make any more to it.
2708          */
2709         if (sip->i_d.di_nlink >= XFS_MAXLINK) {
2710                 error = XFS_ERROR(EMLINK);
2711                 goto error_return;
2712         }
2713
2714         /*
2715          * If we are using project inheritance, we only allow hard link
2716          * creation in our tree when the project IDs are the same; else
2717          * the tree quota mechanism could be circumvented.
2718          */
2719         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
2720                      (tdp->i_d.di_projid != sip->i_d.di_projid))) {
2721                 error = XFS_ERROR(EXDEV);
2722                 goto error_return;
2723         }
2724
2725         if (resblks == 0 &&
2726             (error = xfs_dir_canenter(tp, tdp, target_name, target_namelen)))
2727                 goto error_return;
2728
2729         XFS_BMAP_INIT(&free_list, &first_block);
2730
2731         error = xfs_dir_createname(tp, tdp, target_name, target_namelen,
2732                                    sip->i_ino, &first_block, &free_list,
2733                                    resblks);
2734         if (error)
2735                 goto abort_return;
2736         xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2737         tdp->i_gen++;
2738         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
2739
2740         error = xfs_bumplink(tp, sip);
2741         if (error)
2742                 goto abort_return;
2743
2744         /*
2745          * If this is a synchronous mount, make sure that the
2746          * link transaction goes to disk before returning to
2747          * the user.
2748          */
2749         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2750                 xfs_trans_set_sync(tp);
2751         }
2752
2753         error = xfs_bmap_finish (&tp, &free_list, &committed);
2754         if (error) {
2755                 xfs_bmap_cancel(&free_list);
2756                 goto abort_return;
2757         }
2758
2759         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2760         if (error)
2761                 goto std_return;
2762
2763         /* Fall through to std_return with error = 0. */
2764 std_return:
2765         if (DM_EVENT_ENABLED(src_vp->v_vfsp, sip,
2766                                                 DM_EVENT_POSTLINK)) {
2767                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTLINK,
2768                                 target_dir_vp, DM_RIGHT_NULL,
2769                                 src_vp, DM_RIGHT_NULL,
2770                                 target_name, NULL, 0, error, 0);
2771         }
2772         return error;
2773
2774  abort_return:
2775         cancel_flags |= XFS_TRANS_ABORT;
2776         /* FALLTHROUGH */
2777
2778  error_return:
2779         xfs_trans_cancel(tp, cancel_flags);
2780         goto std_return;
2781 }
2782
2783
2784 /*
2785  * xfs_mkdir
2786  *
2787  */
2788 STATIC int
2789 xfs_mkdir(
2790         bhv_desc_t              *dir_bdp,
2791         bhv_vname_t             *dentry,
2792         bhv_vattr_t             *vap,
2793         bhv_vnode_t             **vpp,
2794         cred_t                  *credp)
2795 {
2796         char                    *dir_name = VNAME(dentry);
2797         xfs_inode_t             *dp;
2798         xfs_inode_t             *cdp;   /* inode of created dir */
2799         bhv_vnode_t             *cvp;   /* vnode of created dir */
2800         xfs_trans_t             *tp;
2801         xfs_mount_t             *mp;
2802         int                     cancel_flags;
2803         int                     error;
2804         int                     committed;
2805         xfs_bmap_free_t         free_list;
2806         xfs_fsblock_t           first_block;
2807         bhv_vnode_t             *dir_vp;
2808         boolean_t               dp_joined_to_trans;
2809         boolean_t               created = B_FALSE;
2810         int                     dm_event_sent = 0;
2811         xfs_prid_t              prid;
2812         struct xfs_dquot        *udqp, *gdqp;
2813         uint                    resblks;
2814         int                     dm_di_mode;
2815         int                     dir_namelen;
2816
2817         dir_vp = BHV_TO_VNODE(dir_bdp);
2818         dp = XFS_BHVTOI(dir_bdp);
2819         mp = dp->i_mount;
2820
2821         if (XFS_FORCED_SHUTDOWN(mp))
2822                 return XFS_ERROR(EIO);
2823
2824         dir_namelen = VNAMELEN(dentry);
2825
2826         tp = NULL;
2827         dp_joined_to_trans = B_FALSE;
2828         dm_di_mode = vap->va_mode;
2829
2830         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
2831                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
2832                                         dir_vp, DM_RIGHT_NULL, NULL,
2833                                         DM_RIGHT_NULL, dir_name, NULL,
2834                                         dm_di_mode, 0, 0);
2835                 if (error)
2836                         return error;
2837                 dm_event_sent = 1;
2838         }
2839
2840         /* Return through std_return after this point. */
2841
2842         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
2843
2844         mp = dp->i_mount;
2845         udqp = gdqp = NULL;
2846         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
2847                 prid = dp->i_d.di_projid;
2848         else if (vap->va_mask & XFS_AT_PROJID)
2849                 prid = (xfs_prid_t)vap->va_projid;
2850         else
2851                 prid = (xfs_prid_t)dfltprid;
2852
2853         /*
2854          * Make sure that we have allocated dquot(s) on disk.
2855          */
2856         error = XFS_QM_DQVOPALLOC(mp, dp,
2857                         current_fsuid(credp), current_fsgid(credp), prid,
2858                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
2859         if (error)
2860                 goto std_return;
2861
2862         tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
2863         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2864         resblks = XFS_MKDIR_SPACE_RES(mp, dir_namelen);
2865         error = xfs_trans_reserve(tp, resblks, XFS_MKDIR_LOG_RES(mp), 0,
2866                                   XFS_TRANS_PERM_LOG_RES, XFS_MKDIR_LOG_COUNT);
2867         if (error == ENOSPC) {
2868                 resblks = 0;
2869                 error = xfs_trans_reserve(tp, 0, XFS_MKDIR_LOG_RES(mp), 0,
2870                                           XFS_TRANS_PERM_LOG_RES,
2871                                           XFS_MKDIR_LOG_COUNT);
2872         }
2873         if (error) {
2874                 cancel_flags = 0;
2875                 dp = NULL;
2876                 goto error_return;
2877         }
2878
2879         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
2880
2881         /*
2882          * Check for directory link count overflow.
2883          */
2884         if (dp->i_d.di_nlink >= XFS_MAXLINK) {
2885                 error = XFS_ERROR(EMLINK);
2886                 goto error_return;
2887         }
2888
2889         /*
2890          * Reserve disk quota and the inode.
2891          */
2892         error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
2893         if (error)
2894                 goto error_return;
2895
2896         if (resblks == 0 &&
2897             (error = xfs_dir_canenter(tp, dp, dir_name, dir_namelen)))
2898                 goto error_return;
2899         /*
2900          * create the directory inode.
2901          */
2902         error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 2,
2903                         0, credp, prid, resblks > 0,
2904                 &cdp, NULL);
2905         if (error) {
2906                 if (error == ENOSPC)
2907                         goto error_return;
2908                 goto abort_return;
2909         }
2910         ITRACE(cdp);
2911
2912         /*
2913          * Now we add the directory inode to the transaction.
2914          * We waited until now since xfs_dir_ialloc might start
2915          * a new transaction.  Had we joined the transaction
2916          * earlier, the locks might have gotten released.
2917          */
2918         VN_HOLD(dir_vp);
2919         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2920         dp_joined_to_trans = B_TRUE;
2921
2922         XFS_BMAP_INIT(&free_list, &first_block);
2923
2924         error = xfs_dir_createname(tp, dp, dir_name, dir_namelen, cdp->i_ino,
2925                                    &first_block, &free_list, resblks ?
2926                                    resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
2927         if (error) {
2928                 ASSERT(error != ENOSPC);
2929                 goto error1;
2930         }
2931         xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2932
2933         /*
2934          * Bump the in memory version number of the parent directory
2935          * so that other processes accessing it will recognize that
2936          * the directory has changed.
2937          */
2938         dp->i_gen++;
2939
2940         error = xfs_dir_init(tp, cdp, dp);
2941         if (error)
2942                 goto error2;
2943
2944         cdp->i_gen = 1;
2945         error = xfs_bumplink(tp, dp);
2946         if (error)
2947                 goto error2;
2948
2949         cvp = XFS_ITOV(cdp);
2950
2951         created = B_TRUE;
2952
2953         *vpp = cvp;
2954         IHOLD(cdp);
2955
2956         /*
2957          * Attach the dquots to the new inode and modify the icount incore.
2958          */
2959         XFS_QM_DQVOPCREATE(mp, tp, cdp, udqp, gdqp);
2960
2961         /*
2962          * If this is a synchronous mount, make sure that the
2963          * mkdir transaction goes to disk before returning to
2964          * the user.
2965          */
2966         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2967                 xfs_trans_set_sync(tp);
2968         }
2969
2970         error = xfs_bmap_finish(&tp, &free_list, &committed);
2971         if (error) {
2972                 IRELE(cdp);
2973                 goto error2;
2974         }
2975
2976         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2977         XFS_QM_DQRELE(mp, udqp);
2978         XFS_QM_DQRELE(mp, gdqp);
2979         if (error) {
2980                 IRELE(cdp);
2981         }
2982
2983         /* Fall through to std_return with error = 0 or errno from
2984          * xfs_trans_commit. */
2985
2986 std_return:
2987         if ( (created || (error != 0 && dm_event_sent != 0)) &&
2988                         DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
2989                                                 DM_EVENT_POSTCREATE)) {
2990                 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
2991                                         dir_vp, DM_RIGHT_NULL,
2992                                         created ? XFS_ITOV(cdp):NULL,
2993                                         DM_RIGHT_NULL,
2994                                         dir_name, NULL,
2995                                         dm_di_mode, error, 0);
2996         }
2997         return error;
2998
2999  error2:
3000  error1:
3001         xfs_bmap_cancel(&free_list);
3002  abort_return:
3003         cancel_flags |= XFS_TRANS_ABORT;
3004  error_return:
3005         xfs_trans_cancel(tp, cancel_flags);
3006         XFS_QM_DQRELE(mp, udqp);
3007         XFS_QM_DQRELE(mp, gdqp);
3008
3009         if (!dp_joined_to_trans && (dp != NULL)) {
3010                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
3011         }
3012
3013         goto std_return;
3014 }
3015
3016
3017 /*
3018  * xfs_rmdir
3019  *
3020  */
3021 STATIC int
3022 xfs_rmdir(
3023         bhv_desc_t              *dir_bdp,
3024         bhv_vname_t             *dentry,
3025         cred_t                  *credp)
3026 {
3027         char                    *name = VNAME(dentry);
3028         xfs_inode_t             *dp;
3029         xfs_inode_t             *cdp;   /* child directory */
3030         xfs_trans_t             *tp;
3031         xfs_mount_t             *mp;
3032         int                     error;
3033         xfs_bmap_free_t         free_list;
3034         xfs_fsblock_t           first_block;
3035         int                     cancel_flags;
3036         int                     committed;
3037         bhv_vnode_t             *dir_vp;
3038         int                     dm_di_mode = S_IFDIR;
3039         int                     last_cdp_link;
3040         int                     namelen;
3041         uint                    resblks;
3042
3043         dir_vp = BHV_TO_VNODE(dir_bdp);
3044         dp = XFS_BHVTOI(dir_bdp);
3045         mp = dp->i_mount;
3046
3047         vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
3048
3049         if (XFS_FORCED_SHUTDOWN(XFS_BHVTOI(dir_bdp)->i_mount))
3050                 return XFS_ERROR(EIO);
3051         namelen = VNAMELEN(dentry);
3052
3053         if (!xfs_get_dir_entry(dentry, &cdp)) {
3054                 dm_di_mode = cdp->i_d.di_mode;
3055                 IRELE(cdp);
3056         }
3057
3058         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_REMOVE)) {
3059                 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE,
3060                                         dir_vp, DM_RIGHT_NULL,
3061                                         NULL, DM_RIGHT_NULL,
3062                                         name, NULL, dm_di_mode, 0, 0);
3063                 if (error)
3064                         return XFS_ERROR(error);
3065         }
3066
3067         /* Return through std_return after this point. */
3068
3069         cdp = NULL;
3070
3071         /*
3072          * We need to get a reference to cdp before we get our log
3073          * reservation.  The reason for this is that we cannot call
3074          * xfs_iget for an inode for which we do not have a reference
3075          * once we've acquired a log reservation.  This is because the
3076          * inode we are trying to get might be in xfs_inactive going
3077          * for a log reservation.  Since we'll have to wait for the
3078          * inactive code to complete before returning from xfs_iget,
3079          * we need to make sure that we don't have log space reserved
3080          * when we call xfs_iget.  Instead we get an unlocked reference
3081         &