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