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