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