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