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