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