Linux-2.6.12-rc2
[linux-3.10.git] / fs / xfs / xfs_fsops.c
1 /*
2  * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of version 2 of the GNU General Public License as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it would be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  *
12  * Further, this software is distributed without any warranty that it is
13  * free of the rightful claim of any third person regarding infringement
14  * or the like.  Any license provided herein, whether implied or
15  * otherwise, applies only to this software file.  Patent licenses, if
16  * any, provided herein do not apply to combinations of this program with
17  * other software, or any other product whatsoever.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write the Free Software Foundation, Inc., 59
21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22  *
23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24  * Mountain View, CA  94043, or:
25  *
26  * http://www.sgi.com
27  *
28  * For further information regarding this notice, see:
29  *
30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31  */
32
33 #include "xfs.h"
34 #include "xfs_macros.h"
35 #include "xfs_types.h"
36 #include "xfs_inum.h"
37 #include "xfs_log.h"
38 #include "xfs_trans.h"
39 #include "xfs_sb.h"
40 #include "xfs_dir.h"
41 #include "xfs_dmapi.h"
42 #include "xfs_mount.h"
43 #include "xfs_ag.h"
44 #include "xfs_alloc_btree.h"
45 #include "xfs_bmap_btree.h"
46 #include "xfs_ialloc_btree.h"
47 #include "xfs_btree.h"
48 #include "xfs_error.h"
49 #include "xfs_alloc.h"
50 #include "xfs_ialloc.h"
51 #include "xfs_fsops.h"
52 #include "xfs_itable.h"
53 #include "xfs_rw.h"
54 #include "xfs_refcache.h"
55 #include "xfs_trans_space.h"
56 #include "xfs_rtalloc.h"
57 #include "xfs_dir2.h"
58 #include "xfs_attr_sf.h"
59 #include "xfs_dir_sf.h"
60 #include "xfs_dir2_sf.h"
61 #include "xfs_dinode.h"
62 #include "xfs_inode.h"
63 #include "xfs_inode_item.h"
64
65 /*
66  * File system operations
67  */
68
69 int
70 xfs_fs_geometry(
71         xfs_mount_t             *mp,
72         xfs_fsop_geom_t         *geo,
73         int                     new_version)
74 {
75         geo->blocksize = mp->m_sb.sb_blocksize;
76         geo->rtextsize = mp->m_sb.sb_rextsize;
77         geo->agblocks = mp->m_sb.sb_agblocks;
78         geo->agcount = mp->m_sb.sb_agcount;
79         geo->logblocks = mp->m_sb.sb_logblocks;
80         geo->sectsize = mp->m_sb.sb_sectsize;
81         geo->inodesize = mp->m_sb.sb_inodesize;
82         geo->imaxpct = mp->m_sb.sb_imax_pct;
83         geo->datablocks = mp->m_sb.sb_dblocks;
84         geo->rtblocks = mp->m_sb.sb_rblocks;
85         geo->rtextents = mp->m_sb.sb_rextents;
86         geo->logstart = mp->m_sb.sb_logstart;
87         ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid));
88         memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid));
89         if (new_version >= 2) {
90                 geo->sunit = mp->m_sb.sb_unit;
91                 geo->swidth = mp->m_sb.sb_width;
92         }
93         if (new_version >= 3) {
94                 geo->version = XFS_FSOP_GEOM_VERSION;
95                 geo->flags =
96                         (XFS_SB_VERSION_HASATTR(&mp->m_sb) ?
97                                 XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
98                         (XFS_SB_VERSION_HASNLINK(&mp->m_sb) ?
99                                 XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
100                         (XFS_SB_VERSION_HASQUOTA(&mp->m_sb) ?
101                                 XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
102                         (XFS_SB_VERSION_HASALIGN(&mp->m_sb) ?
103                                 XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
104                         (XFS_SB_VERSION_HASDALIGN(&mp->m_sb) ?
105                                 XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
106                         (XFS_SB_VERSION_HASSHARED(&mp->m_sb) ?
107                                 XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
108                         (XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) ?
109                                 XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
110                         (XFS_SB_VERSION_HASDIRV2(&mp->m_sb) ?
111                                 XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
112                         (XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
113                                 XFS_FSOP_GEOM_FLAGS_SECTOR : 0);
114                 geo->logsectsize = XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
115                                 mp->m_sb.sb_logsectsize : BBSIZE;
116                 geo->rtsectsize = mp->m_sb.sb_blocksize;
117                 geo->dirblocksize = mp->m_dirblksize;
118         }
119         if (new_version >= 4) {
120                 geo->flags |=
121                         (XFS_SB_VERSION_HASLOGV2(&mp->m_sb) ?
122                                 XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
123                 geo->logsunit = mp->m_sb.sb_logsunit;
124         }
125         return 0;
126 }
127
128 static int
129 xfs_growfs_data_private(
130         xfs_mount_t             *mp,            /* mount point for filesystem */
131         xfs_growfs_data_t       *in)            /* growfs data input struct */
132 {
133         xfs_agf_t               *agf;
134         xfs_agi_t               *agi;
135         xfs_agnumber_t          agno;
136         xfs_extlen_t            agsize;
137         xfs_extlen_t            tmpsize;
138         xfs_alloc_rec_t         *arec;
139         xfs_btree_sblock_t      *block;
140         xfs_buf_t               *bp;
141         int                     bucket;
142         int                     dpct;
143         int                     error;
144         xfs_agnumber_t          nagcount;
145         xfs_agnumber_t          nagimax = 0;
146         xfs_rfsblock_t          nb, nb_mod;
147         xfs_rfsblock_t          new;
148         xfs_rfsblock_t          nfree;
149         xfs_agnumber_t          oagcount;
150         int                     pct;
151         xfs_sb_t                *sbp;
152         xfs_trans_t             *tp;
153
154         nb = in->newblocks;
155         pct = in->imaxpct;
156         if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
157                 return XFS_ERROR(EINVAL);
158         dpct = pct - mp->m_sb.sb_imax_pct;
159         error = xfs_read_buf(mp, mp->m_ddev_targp,
160                         XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
161                         XFS_FSS_TO_BB(mp, 1), 0, &bp);
162         if (error)
163                 return error;
164         ASSERT(bp);
165         xfs_buf_relse(bp);
166
167         new = nb;       /* use new as a temporary here */
168         nb_mod = do_div(new, mp->m_sb.sb_agblocks);
169         nagcount = new + (nb_mod != 0);
170         if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
171                 nagcount--;
172                 nb = nagcount * mp->m_sb.sb_agblocks;
173                 if (nb < mp->m_sb.sb_dblocks)
174                         return XFS_ERROR(EINVAL);
175         }
176         new = nb - mp->m_sb.sb_dblocks;
177         oagcount = mp->m_sb.sb_agcount;
178         if (nagcount > oagcount) {
179                 down_write(&mp->m_peraglock);
180                 mp->m_perag = kmem_realloc(mp->m_perag,
181                         sizeof(xfs_perag_t) * nagcount,
182                         sizeof(xfs_perag_t) * oagcount,
183                         KM_SLEEP);
184                 memset(&mp->m_perag[oagcount], 0,
185                         (nagcount - oagcount) * sizeof(xfs_perag_t));
186                 mp->m_flags |= XFS_MOUNT_32BITINODES;
187                 nagimax = xfs_initialize_perag(mp, nagcount);
188                 up_write(&mp->m_peraglock);
189         }
190         tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
191         if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
192                         XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) {
193                 xfs_trans_cancel(tp, 0);
194                 return error;
195         }
196
197         nfree = 0;
198         for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
199                 /*
200                  * AG freelist header block
201                  */
202                 bp = xfs_buf_get(mp->m_ddev_targp,
203                                   XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
204                                   XFS_FSS_TO_BB(mp, 1), 0);
205                 agf = XFS_BUF_TO_AGF(bp);
206                 memset(agf, 0, mp->m_sb.sb_sectsize);
207                 INT_SET(agf->agf_magicnum, ARCH_CONVERT, XFS_AGF_MAGIC);
208                 INT_SET(agf->agf_versionnum, ARCH_CONVERT, XFS_AGF_VERSION);
209                 INT_SET(agf->agf_seqno, ARCH_CONVERT, agno);
210                 if (agno == nagcount - 1)
211                         agsize =
212                                 nb -
213                                 (agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
214                 else
215                         agsize = mp->m_sb.sb_agblocks;
216                 INT_SET(agf->agf_length, ARCH_CONVERT, agsize);
217                 INT_SET(agf->agf_roots[XFS_BTNUM_BNOi], ARCH_CONVERT,
218                         XFS_BNO_BLOCK(mp));
219                 INT_SET(agf->agf_roots[XFS_BTNUM_CNTi], ARCH_CONVERT,
220                         XFS_CNT_BLOCK(mp));
221                 INT_SET(agf->agf_levels[XFS_BTNUM_BNOi], ARCH_CONVERT, 1);
222                 INT_SET(agf->agf_levels[XFS_BTNUM_CNTi], ARCH_CONVERT, 1);
223                 agf->agf_flfirst = 0;
224                 INT_SET(agf->agf_fllast, ARCH_CONVERT, XFS_AGFL_SIZE(mp) - 1);
225                 agf->agf_flcount = 0;
226                 tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
227                 INT_SET(agf->agf_freeblks, ARCH_CONVERT, tmpsize);
228                 INT_SET(agf->agf_longest, ARCH_CONVERT, tmpsize);
229                 error = xfs_bwrite(mp, bp);
230                 if (error) {
231                         goto error0;
232                 }
233                 /*
234                  * AG inode header block
235                  */
236                 bp = xfs_buf_get(mp->m_ddev_targp,
237                                   XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
238                                   XFS_FSS_TO_BB(mp, 1), 0);
239                 agi = XFS_BUF_TO_AGI(bp);
240                 memset(agi, 0, mp->m_sb.sb_sectsize);
241                 INT_SET(agi->agi_magicnum, ARCH_CONVERT, XFS_AGI_MAGIC);
242                 INT_SET(agi->agi_versionnum, ARCH_CONVERT, XFS_AGI_VERSION);
243                 INT_SET(agi->agi_seqno, ARCH_CONVERT, agno);
244                 INT_SET(agi->agi_length, ARCH_CONVERT, agsize);
245                 agi->agi_count = 0;
246                 INT_SET(agi->agi_root, ARCH_CONVERT, XFS_IBT_BLOCK(mp));
247                 INT_SET(agi->agi_level, ARCH_CONVERT, 1);
248                 agi->agi_freecount = 0;
249                 INT_SET(agi->agi_newino, ARCH_CONVERT, NULLAGINO);
250                 INT_SET(agi->agi_dirino, ARCH_CONVERT, NULLAGINO);
251                 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
252                         INT_SET(agi->agi_unlinked[bucket], ARCH_CONVERT,
253                                 NULLAGINO);
254                 error = xfs_bwrite(mp, bp);
255                 if (error) {
256                         goto error0;
257                 }
258                 /*
259                  * BNO btree root block
260                  */
261                 bp = xfs_buf_get(mp->m_ddev_targp,
262                         XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
263                         BTOBB(mp->m_sb.sb_blocksize), 0);
264                 block = XFS_BUF_TO_SBLOCK(bp);
265                 memset(block, 0, mp->m_sb.sb_blocksize);
266                 INT_SET(block->bb_magic, ARCH_CONVERT, XFS_ABTB_MAGIC);
267                 block->bb_level = 0;
268                 INT_SET(block->bb_numrecs, ARCH_CONVERT, 1);
269                 INT_SET(block->bb_leftsib, ARCH_CONVERT, NULLAGBLOCK);
270                 INT_SET(block->bb_rightsib, ARCH_CONVERT, NULLAGBLOCK);
271                 arec = XFS_BTREE_REC_ADDR(mp->m_sb.sb_blocksize, xfs_alloc,
272                         block, 1, mp->m_alloc_mxr[0]);
273                 INT_SET(arec->ar_startblock, ARCH_CONVERT,
274                         XFS_PREALLOC_BLOCKS(mp));
275                 INT_SET(arec->ar_blockcount, ARCH_CONVERT,
276                         agsize - INT_GET(arec->ar_startblock, ARCH_CONVERT));
277                 error = xfs_bwrite(mp, bp);
278                 if (error) {
279                         goto error0;
280                 }
281                 /*
282                  * CNT btree root block
283                  */
284                 bp = xfs_buf_get(mp->m_ddev_targp,
285                         XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
286                         BTOBB(mp->m_sb.sb_blocksize), 0);
287                 block = XFS_BUF_TO_SBLOCK(bp);
288                 memset(block, 0, mp->m_sb.sb_blocksize);
289                 INT_SET(block->bb_magic, ARCH_CONVERT, XFS_ABTC_MAGIC);
290                 block->bb_level = 0;
291                 INT_SET(block->bb_numrecs, ARCH_CONVERT, 1);
292                 INT_SET(block->bb_leftsib, ARCH_CONVERT, NULLAGBLOCK);
293                 INT_SET(block->bb_rightsib, ARCH_CONVERT, NULLAGBLOCK);
294                 arec = XFS_BTREE_REC_ADDR(mp->m_sb.sb_blocksize, xfs_alloc,
295                         block, 1, mp->m_alloc_mxr[0]);
296                 INT_SET(arec->ar_startblock, ARCH_CONVERT,
297                         XFS_PREALLOC_BLOCKS(mp));
298                 INT_SET(arec->ar_blockcount, ARCH_CONVERT,
299                         agsize - INT_GET(arec->ar_startblock, ARCH_CONVERT));
300                 nfree += INT_GET(arec->ar_blockcount, ARCH_CONVERT);
301                 error = xfs_bwrite(mp, bp);
302                 if (error) {
303                         goto error0;
304                 }
305                 /*
306                  * INO btree root block
307                  */
308                 bp = xfs_buf_get(mp->m_ddev_targp,
309                         XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
310                         BTOBB(mp->m_sb.sb_blocksize), 0);
311                 block = XFS_BUF_TO_SBLOCK(bp);
312                 memset(block, 0, mp->m_sb.sb_blocksize);
313                 INT_SET(block->bb_magic, ARCH_CONVERT, XFS_IBT_MAGIC);
314                 block->bb_level = 0;
315                 block->bb_numrecs = 0;
316                 INT_SET(block->bb_leftsib, ARCH_CONVERT, NULLAGBLOCK);
317                 INT_SET(block->bb_rightsib, ARCH_CONVERT, NULLAGBLOCK);
318                 error = xfs_bwrite(mp, bp);
319                 if (error) {
320                         goto error0;
321                 }
322         }
323         xfs_trans_agblocks_delta(tp, nfree);
324         /*
325          * There are new blocks in the old last a.g.
326          */
327         if (new) {
328                 /*
329                  * Change the agi length.
330                  */
331                 error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
332                 if (error) {
333                         goto error0;
334                 }
335                 ASSERT(bp);
336                 agi = XFS_BUF_TO_AGI(bp);
337                 INT_MOD(agi->agi_length, ARCH_CONVERT, new);
338                 ASSERT(nagcount == oagcount ||
339                        INT_GET(agi->agi_length, ARCH_CONVERT) ==
340                                 mp->m_sb.sb_agblocks);
341                 xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
342                 /*
343                  * Change agf length.
344                  */
345                 error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
346                 if (error) {
347                         goto error0;
348                 }
349                 ASSERT(bp);
350                 agf = XFS_BUF_TO_AGF(bp);
351                 INT_MOD(agf->agf_length, ARCH_CONVERT, new);
352                 ASSERT(INT_GET(agf->agf_length, ARCH_CONVERT) ==
353                                 INT_GET(agi->agi_length, ARCH_CONVERT));
354                 /*
355                  * Free the new space.
356                  */
357                 error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
358                         INT_GET(agf->agf_length, ARCH_CONVERT) - new), new);
359                 if (error) {
360                         goto error0;
361                 }
362         }
363         if (nagcount > oagcount)
364                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
365         if (nb > mp->m_sb.sb_dblocks)
366                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
367                                  nb - mp->m_sb.sb_dblocks);
368         if (nfree)
369                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
370         if (dpct)
371                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
372         error = xfs_trans_commit(tp, 0, NULL);
373         if (error) {
374                 return error;
375         }
376         /* New allocation groups fully initialized, so update mount struct */
377         if (nagimax)
378                 mp->m_maxagi = nagimax;
379         if (mp->m_sb.sb_imax_pct) {
380                 __uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
381                 do_div(icount, 100);
382                 mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
383         } else
384                 mp->m_maxicount = 0;
385         for (agno = 1; agno < nagcount; agno++) {
386                 error = xfs_read_buf(mp, mp->m_ddev_targp,
387                                   XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
388                                   XFS_FSS_TO_BB(mp, 1), 0, &bp);
389                 if (error) {
390                         xfs_fs_cmn_err(CE_WARN, mp,
391                         "error %d reading secondary superblock for ag %d",
392                                 error, agno);
393                         break;
394                 }
395                 sbp = XFS_BUF_TO_SBP(bp);
396                 xfs_xlatesb(sbp, &mp->m_sb, -1, XFS_SB_ALL_BITS);
397                 /*
398                  * If we get an error writing out the alternate superblocks,
399                  * just issue a warning and continue.  The real work is
400                  * already done and committed.
401                  */
402                 if (!(error = xfs_bwrite(mp, bp))) {
403                         continue;
404                 } else {
405                         xfs_fs_cmn_err(CE_WARN, mp,
406                 "write error %d updating secondary superblock for ag %d",
407                                 error, agno);
408                         break; /* no point in continuing */
409                 }
410         }
411         return 0;
412
413  error0:
414         xfs_trans_cancel(tp, XFS_TRANS_ABORT);
415         return error;
416 }
417
418 static int
419 xfs_growfs_log_private(
420         xfs_mount_t             *mp,    /* mount point for filesystem */
421         xfs_growfs_log_t        *in)    /* growfs log input struct */
422 {
423         xfs_extlen_t            nb;
424
425         nb = in->newblocks;
426         if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
427                 return XFS_ERROR(EINVAL);
428         if (nb == mp->m_sb.sb_logblocks &&
429             in->isint == (mp->m_sb.sb_logstart != 0))
430                 return XFS_ERROR(EINVAL);
431         /*
432          * Moving the log is hard, need new interfaces to sync
433          * the log first, hold off all activity while moving it.
434          * Can have shorter or longer log in the same space,
435          * or transform internal to external log or vice versa.
436          */
437         return XFS_ERROR(ENOSYS);
438 }
439
440 /*
441  * protected versions of growfs function acquire and release locks on the mount
442  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
443  * XFS_IOC_FSGROWFSRT
444  */
445
446
447 int
448 xfs_growfs_data(
449         xfs_mount_t             *mp,
450         xfs_growfs_data_t       *in)
451 {
452         int error;
453         if (!cpsema(&mp->m_growlock))
454                 return XFS_ERROR(EWOULDBLOCK);
455         error = xfs_growfs_data_private(mp, in);
456         vsema(&mp->m_growlock);
457         return error;
458 }
459
460 int
461 xfs_growfs_log(
462         xfs_mount_t             *mp,
463         xfs_growfs_log_t        *in)
464 {
465         int error;
466         if (!cpsema(&mp->m_growlock))
467                 return XFS_ERROR(EWOULDBLOCK);
468         error = xfs_growfs_log_private(mp, in);
469         vsema(&mp->m_growlock);
470         return error;
471 }
472
473 /*
474  * exported through ioctl XFS_IOC_FSCOUNTS
475  */
476
477 int
478 xfs_fs_counts(
479         xfs_mount_t             *mp,
480         xfs_fsop_counts_t       *cnt)
481 {
482         unsigned long   s;
483
484         s = XFS_SB_LOCK(mp);
485         cnt->freedata = mp->m_sb.sb_fdblocks;
486         cnt->freertx = mp->m_sb.sb_frextents;
487         cnt->freeino = mp->m_sb.sb_ifree;
488         cnt->allocino = mp->m_sb.sb_icount;
489         XFS_SB_UNLOCK(mp, s);
490         return 0;
491 }
492
493 /*
494  * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
495  *
496  * xfs_reserve_blocks is called to set m_resblks
497  * in the in-core mount table. The number of unused reserved blocks
498  * is kept in m_resbls_avail.
499  *
500  * Reserve the requested number of blocks if available. Otherwise return
501  * as many as possible to satisfy the request. The actual number
502  * reserved are returned in outval
503  *
504  * A null inval pointer indicates that only the current reserved blocks
505  * available  should  be returned no settings are changed.
506  */
507
508 int
509 xfs_reserve_blocks(
510         xfs_mount_t             *mp,
511         __uint64_t              *inval,
512         xfs_fsop_resblks_t      *outval)
513 {
514         __int64_t               lcounter, delta;
515         __uint64_t              request;
516         unsigned long           s;
517
518         /* If inval is null, report current values and return */
519
520         if (inval == (__uint64_t *)NULL) {
521                 outval->resblks = mp->m_resblks;
522                 outval->resblks_avail = mp->m_resblks_avail;
523                 return(0);
524         }
525
526         request = *inval;
527         s = XFS_SB_LOCK(mp);
528
529         /*
530          * If our previous reservation was larger than the current value,
531          * then move any unused blocks back to the free pool.
532          */
533
534         if (mp->m_resblks > request) {
535                 lcounter = mp->m_resblks_avail - request;
536                 if (lcounter  > 0) {            /* release unused blocks */
537                         mp->m_sb.sb_fdblocks += lcounter;
538                         mp->m_resblks_avail -= lcounter;
539                 }
540                 mp->m_resblks = request;
541         } else {
542                 delta = request - mp->m_resblks;
543                 lcounter = mp->m_sb.sb_fdblocks - delta;
544                 if (lcounter < 0) {
545                         /* We can't satisfy the request, just get what we can */
546                         mp->m_resblks += mp->m_sb.sb_fdblocks;
547                         mp->m_resblks_avail += mp->m_sb.sb_fdblocks;
548                         mp->m_sb.sb_fdblocks = 0;
549                 } else {
550                         mp->m_sb.sb_fdblocks = lcounter;
551                         mp->m_resblks = request;
552                         mp->m_resblks_avail += delta;
553                 }
554         }
555
556         outval->resblks = mp->m_resblks;
557         outval->resblks_avail = mp->m_resblks_avail;
558         XFS_SB_UNLOCK(mp, s);
559         return(0);
560 }
561
562 void
563 xfs_fs_log_dummy(xfs_mount_t *mp)
564 {
565         xfs_trans_t *tp;
566         xfs_inode_t *ip;
567
568
569         tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
570         atomic_inc(&mp->m_active_trans);
571         if (xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0)) {
572                 xfs_trans_cancel(tp, 0);
573                 return;
574         }
575
576         ip = mp->m_rootip;
577         xfs_ilock(ip, XFS_ILOCK_EXCL);
578
579         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
580         xfs_trans_ihold(tp, ip);
581         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
582         xfs_trans_set_sync(tp);
583         xfs_trans_commit(tp, 0, NULL);
584
585         xfs_iunlock(ip, XFS_ILOCK_EXCL);
586 }
587
588 int
589 xfs_fs_goingdown(
590         xfs_mount_t     *mp,
591         __uint32_t      inflags)
592 {
593         switch (inflags) {
594         case XFS_FSOP_GOING_FLAGS_DEFAULT: {
595                 struct vfs *vfsp = XFS_MTOVFS(mp);
596                 struct super_block *sb = freeze_bdev(vfsp->vfs_super->s_bdev);
597
598                 if (sb) {
599                         xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
600                         thaw_bdev(sb->s_bdev, sb);
601                 }
602         
603                 break;
604         }
605         case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
606                 xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
607                 break;
608         case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
609                 xfs_force_shutdown(mp, XFS_FORCE_UMOUNT|XFS_LOG_IO_ERROR);
610                 break;
611         default:
612                 return XFS_ERROR(EINVAL);
613         }
614
615         return 0;
616 }