1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
7 * Inspired by ext3/resize.c.
9 * Copyright (C) 2007 Oracle. All rights reserved.
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public
22 * License along with this program; if not, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 021110-1307, USA.
28 #include <linux/types.h>
30 #define MLOG_MASK_PREFIX ML_DISK_ALLOC
31 #include <cluster/masklog.h>
42 #include "ocfs2_trace.h"
44 #include "buffer_head_io.h"
49 * Check whether there are new backup superblocks exist
50 * in the last group. If there are some, mark them or clear
53 * Return how many backups we find in the last group.
55 static u16
ocfs2_calc_new_backup_super(struct inode
*inode
,
56 struct ocfs2_group_desc
*gd
,
58 u32 first_new_cluster
,
65 u64 blkno
, gd_blkno
, lgd_blkno
= le64_to_cpu(gd
->bg_blkno
);
67 for (i
= 0; i
< OCFS2_MAX_BACKUP_SUPERBLOCKS
; i
++) {
68 blkno
= ocfs2_backup_super_blkno(inode
->i_sb
, i
);
69 cluster
= ocfs2_blocks_to_clusters(inode
->i_sb
, blkno
);
71 gd_blkno
= ocfs2_which_cluster_group(inode
, cluster
);
72 if (gd_blkno
< lgd_blkno
)
74 else if (gd_blkno
> lgd_blkno
)
78 ocfs2_set_bit(cluster
% cl_cpg
,
79 (unsigned long *)gd
->bg_bitmap
);
81 ocfs2_clear_bit(cluster
% cl_cpg
,
82 (unsigned long *)gd
->bg_bitmap
);
89 static int ocfs2_update_last_group_and_inode(handle_t
*handle
,
90 struct inode
*bm_inode
,
91 struct buffer_head
*bm_bh
,
92 struct buffer_head
*group_bh
,
93 u32 first_new_cluster
,
97 struct ocfs2_super
*osb
= OCFS2_SB(bm_inode
->i_sb
);
98 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) bm_bh
->b_data
;
99 struct ocfs2_chain_list
*cl
= &fe
->id2
.i_chain
;
100 struct ocfs2_chain_rec
*cr
;
101 struct ocfs2_group_desc
*group
;
102 u16 chain
, num_bits
, backups
= 0;
103 u16 cl_bpc
= le16_to_cpu(cl
->cl_bpc
);
104 u16 cl_cpg
= le16_to_cpu(cl
->cl_cpg
);
106 trace_ocfs2_update_last_group_and_inode(new_clusters
,
109 ret
= ocfs2_journal_access_gd(handle
, INODE_CACHE(bm_inode
),
110 group_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
116 group
= (struct ocfs2_group_desc
*)group_bh
->b_data
;
118 /* update the group first. */
119 num_bits
= new_clusters
* cl_bpc
;
120 le16_add_cpu(&group
->bg_bits
, num_bits
);
121 le16_add_cpu(&group
->bg_free_bits_count
, num_bits
);
124 * check whether there are some new backup superblocks exist in
125 * this group and update the group bitmap accordingly.
127 if (OCFS2_HAS_COMPAT_FEATURE(osb
->sb
,
128 OCFS2_FEATURE_COMPAT_BACKUP_SB
)) {
129 backups
= ocfs2_calc_new_backup_super(bm_inode
,
134 le16_add_cpu(&group
->bg_free_bits_count
, -1 * backups
);
137 ocfs2_journal_dirty(handle
, group_bh
);
139 /* update the inode accordingly. */
140 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(bm_inode
), bm_bh
,
141 OCFS2_JOURNAL_ACCESS_WRITE
);
147 chain
= le16_to_cpu(group
->bg_chain
);
148 cr
= (&cl
->cl_recs
[chain
]);
149 le32_add_cpu(&cr
->c_total
, num_bits
);
150 le32_add_cpu(&cr
->c_free
, num_bits
);
151 le32_add_cpu(&fe
->id1
.bitmap1
.i_total
, num_bits
);
152 le32_add_cpu(&fe
->i_clusters
, new_clusters
);
155 le32_add_cpu(&cr
->c_free
, -1 * backups
);
156 le32_add_cpu(&fe
->id1
.bitmap1
.i_used
, backups
);
159 spin_lock(&OCFS2_I(bm_inode
)->ip_lock
);
160 OCFS2_I(bm_inode
)->ip_clusters
= le32_to_cpu(fe
->i_clusters
);
161 le64_add_cpu(&fe
->i_size
, new_clusters
<< osb
->s_clustersize_bits
);
162 spin_unlock(&OCFS2_I(bm_inode
)->ip_lock
);
163 i_size_write(bm_inode
, le64_to_cpu(fe
->i_size
));
165 ocfs2_journal_dirty(handle
, bm_bh
);
169 ocfs2_calc_new_backup_super(bm_inode
,
174 le16_add_cpu(&group
->bg_free_bits_count
, backups
);
175 le16_add_cpu(&group
->bg_bits
, -1 * num_bits
);
176 le16_add_cpu(&group
->bg_free_bits_count
, -1 * num_bits
);
184 static int update_backups(struct inode
* inode
, u32 clusters
, char *data
)
189 struct buffer_head
*backup
= NULL
;
190 struct ocfs2_dinode
*backup_di
= NULL
;
191 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
193 /* calculate the real backups we need to update. */
194 for (i
= 0; i
< OCFS2_MAX_BACKUP_SUPERBLOCKS
; i
++) {
195 blkno
= ocfs2_backup_super_blkno(inode
->i_sb
, i
);
196 cluster
= ocfs2_blocks_to_clusters(inode
->i_sb
, blkno
);
197 if (cluster
> clusters
)
200 ret
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &backup
);
206 memcpy(backup
->b_data
, data
, inode
->i_sb
->s_blocksize
);
208 backup_di
= (struct ocfs2_dinode
*)backup
->b_data
;
209 backup_di
->i_blkno
= cpu_to_le64(blkno
);
211 ret
= ocfs2_write_super_or_backup(osb
, backup
);
223 static void ocfs2_update_super_and_backups(struct inode
*inode
,
228 struct buffer_head
*super_bh
= NULL
;
229 struct ocfs2_dinode
*super_di
= NULL
;
230 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
233 * update the superblock last.
234 * It doesn't matter if the write failed.
236 ret
= ocfs2_read_blocks_sync(osb
, OCFS2_SUPER_BLOCK_BLKNO
, 1,
243 super_di
= (struct ocfs2_dinode
*)super_bh
->b_data
;
244 le32_add_cpu(&super_di
->i_clusters
, new_clusters
);
245 clusters
= le32_to_cpu(super_di
->i_clusters
);
247 ret
= ocfs2_write_super_or_backup(osb
, super_bh
);
253 if (OCFS2_HAS_COMPAT_FEATURE(osb
->sb
, OCFS2_FEATURE_COMPAT_BACKUP_SB
))
254 ret
= update_backups(inode
, clusters
, super_bh
->b_data
);
259 printk(KERN_WARNING
"ocfs2: Failed to update super blocks on %s"
260 " during fs resize. This condition is not fatal,"
261 " but fsck.ocfs2 should be run to fix it\n",
267 * Extend the filesystem to the new number of clusters specified. This entry
268 * point is only used to extend the current filesystem to the end of the last
271 int ocfs2_group_extend(struct inode
* inode
, int new_clusters
)
275 struct buffer_head
*main_bm_bh
= NULL
;
276 struct buffer_head
*group_bh
= NULL
;
277 struct inode
*main_bm_inode
= NULL
;
278 struct ocfs2_dinode
*fe
= NULL
;
279 struct ocfs2_group_desc
*group
= NULL
;
280 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
282 u32 first_new_cluster
;
285 if (ocfs2_is_hard_readonly(osb
) || ocfs2_is_soft_readonly(osb
))
288 if (new_clusters
< 0)
290 else if (new_clusters
== 0)
293 main_bm_inode
= ocfs2_get_system_file_inode(osb
,
294 GLOBAL_BITMAP_SYSTEM_INODE
,
296 if (!main_bm_inode
) {
302 mutex_lock(&main_bm_inode
->i_mutex
);
304 ret
= ocfs2_inode_lock(main_bm_inode
, &main_bm_bh
, 1);
310 fe
= (struct ocfs2_dinode
*)main_bm_bh
->b_data
;
312 /* main_bm_bh is validated by inode read inside ocfs2_inode_lock(),
313 * so any corruption is a code bug. */
314 BUG_ON(!OCFS2_IS_VALID_DINODE(fe
));
316 if (le16_to_cpu(fe
->id2
.i_chain
.cl_cpg
) !=
317 ocfs2_group_bitmap_size(osb
->sb
, 0,
318 osb
->s_feature_incompat
) * 8) {
319 mlog(ML_ERROR
, "The disk is too old and small. "
320 "Force to do offline resize.");
325 first_new_cluster
= le32_to_cpu(fe
->i_clusters
);
326 lgd_blkno
= ocfs2_which_cluster_group(main_bm_inode
,
327 first_new_cluster
- 1);
329 ret
= ocfs2_read_group_descriptor(main_bm_inode
, fe
, lgd_blkno
,
335 group
= (struct ocfs2_group_desc
*)group_bh
->b_data
;
337 cl_bpc
= le16_to_cpu(fe
->id2
.i_chain
.cl_bpc
);
338 if (le16_to_cpu(group
->bg_bits
) / cl_bpc
+ new_clusters
>
339 le16_to_cpu(fe
->id2
.i_chain
.cl_cpg
)) {
345 trace_ocfs2_group_extend(
346 (unsigned long long)le64_to_cpu(group
->bg_blkno
), new_clusters
);
348 handle
= ocfs2_start_trans(osb
, OCFS2_GROUP_EXTEND_CREDITS
);
349 if (IS_ERR(handle
)) {
350 mlog_errno(PTR_ERR(handle
));
355 /* update the last group descriptor and inode. */
356 ret
= ocfs2_update_last_group_and_inode(handle
, main_bm_inode
,
357 main_bm_bh
, group_bh
,
365 ocfs2_update_super_and_backups(main_bm_inode
, new_clusters
);
368 ocfs2_commit_trans(osb
, handle
);
373 ocfs2_inode_unlock(main_bm_inode
, 1);
376 mutex_unlock(&main_bm_inode
->i_mutex
);
383 static int ocfs2_check_new_group(struct inode
*inode
,
384 struct ocfs2_dinode
*di
,
385 struct ocfs2_new_group_input
*input
,
386 struct buffer_head
*group_bh
)
389 struct ocfs2_group_desc
*gd
=
390 (struct ocfs2_group_desc
*)group_bh
->b_data
;
391 u16 cl_bpc
= le16_to_cpu(di
->id2
.i_chain
.cl_bpc
);
393 ret
= ocfs2_check_group_descriptor(inode
->i_sb
, di
, group_bh
);
398 if (le16_to_cpu(gd
->bg_chain
) != input
->chain
)
399 mlog(ML_ERROR
, "Group descriptor # %llu has bad chain %u "
400 "while input has %u set.\n",
401 (unsigned long long)le64_to_cpu(gd
->bg_blkno
),
402 le16_to_cpu(gd
->bg_chain
), input
->chain
);
403 else if (le16_to_cpu(gd
->bg_bits
) != input
->clusters
* cl_bpc
)
404 mlog(ML_ERROR
, "Group descriptor # %llu has bit count %u but "
405 "input has %u clusters set\n",
406 (unsigned long long)le64_to_cpu(gd
->bg_blkno
),
407 le16_to_cpu(gd
->bg_bits
), input
->clusters
);
408 else if (le16_to_cpu(gd
->bg_free_bits_count
) != input
->frees
* cl_bpc
)
409 mlog(ML_ERROR
, "Group descriptor # %llu has free bit count %u "
410 "but it should have %u set\n",
411 (unsigned long long)le64_to_cpu(gd
->bg_blkno
),
412 le16_to_cpu(gd
->bg_bits
),
413 input
->frees
* cl_bpc
);
421 static int ocfs2_verify_group_and_input(struct inode
*inode
,
422 struct ocfs2_dinode
*di
,
423 struct ocfs2_new_group_input
*input
,
424 struct buffer_head
*group_bh
)
426 u16 cl_count
= le16_to_cpu(di
->id2
.i_chain
.cl_count
);
427 u16 cl_cpg
= le16_to_cpu(di
->id2
.i_chain
.cl_cpg
);
428 u16 next_free
= le16_to_cpu(di
->id2
.i_chain
.cl_next_free_rec
);
429 u32 cluster
= ocfs2_blocks_to_clusters(inode
->i_sb
, input
->group
);
430 u32 total_clusters
= le32_to_cpu(di
->i_clusters
);
433 if (cluster
< total_clusters
)
434 mlog(ML_ERROR
, "add a group which is in the current volume.\n");
435 else if (input
->chain
>= cl_count
)
436 mlog(ML_ERROR
, "input chain exceeds the limit.\n");
437 else if (next_free
!= cl_count
&& next_free
!= input
->chain
)
439 "the add group should be in chain %u\n", next_free
);
440 else if (total_clusters
+ input
->clusters
< total_clusters
)
441 mlog(ML_ERROR
, "add group's clusters overflow.\n");
442 else if (input
->clusters
> cl_cpg
)
443 mlog(ML_ERROR
, "the cluster exceeds the maximum of a group\n");
444 else if (input
->frees
> input
->clusters
)
445 mlog(ML_ERROR
, "the free cluster exceeds the total clusters\n");
446 else if (total_clusters
% cl_cpg
!= 0)
448 "the last group isn't full. Use group extend first.\n");
449 else if (input
->group
!= ocfs2_which_cluster_group(inode
, cluster
))
450 mlog(ML_ERROR
, "group blkno is invalid\n");
451 else if ((ret
= ocfs2_check_new_group(inode
, di
, input
, group_bh
)))
452 mlog(ML_ERROR
, "group descriptor check failed.\n");
459 /* Add a new group descriptor to global_bitmap. */
460 int ocfs2_group_add(struct inode
*inode
, struct ocfs2_new_group_input
*input
)
464 struct buffer_head
*main_bm_bh
= NULL
;
465 struct inode
*main_bm_inode
= NULL
;
466 struct ocfs2_dinode
*fe
= NULL
;
467 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
468 struct buffer_head
*group_bh
= NULL
;
469 struct ocfs2_group_desc
*group
= NULL
;
470 struct ocfs2_chain_list
*cl
;
471 struct ocfs2_chain_rec
*cr
;
474 if (ocfs2_is_hard_readonly(osb
) || ocfs2_is_soft_readonly(osb
))
477 main_bm_inode
= ocfs2_get_system_file_inode(osb
,
478 GLOBAL_BITMAP_SYSTEM_INODE
,
480 if (!main_bm_inode
) {
486 mutex_lock(&main_bm_inode
->i_mutex
);
488 ret
= ocfs2_inode_lock(main_bm_inode
, &main_bm_bh
, 1);
494 fe
= (struct ocfs2_dinode
*)main_bm_bh
->b_data
;
496 if (le16_to_cpu(fe
->id2
.i_chain
.cl_cpg
) !=
497 ocfs2_group_bitmap_size(osb
->sb
, 0,
498 osb
->s_feature_incompat
) * 8) {
499 mlog(ML_ERROR
, "The disk is too old and small."
500 " Force to do offline resize.");
505 ret
= ocfs2_read_blocks_sync(osb
, input
->group
, 1, &group_bh
);
507 mlog(ML_ERROR
, "Can't read the group descriptor # %llu "
508 "from the device.", (unsigned long long)input
->group
);
512 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), group_bh
);
514 ret
= ocfs2_verify_group_and_input(main_bm_inode
, fe
, input
, group_bh
);
520 trace_ocfs2_group_add((unsigned long long)input
->group
,
521 input
->chain
, input
->clusters
, input
->frees
);
523 handle
= ocfs2_start_trans(osb
, OCFS2_GROUP_ADD_CREDITS
);
524 if (IS_ERR(handle
)) {
525 mlog_errno(PTR_ERR(handle
));
530 cl_bpc
= le16_to_cpu(fe
->id2
.i_chain
.cl_bpc
);
531 cl
= &fe
->id2
.i_chain
;
532 cr
= &cl
->cl_recs
[input
->chain
];
534 ret
= ocfs2_journal_access_gd(handle
, INODE_CACHE(main_bm_inode
),
535 group_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
541 group
= (struct ocfs2_group_desc
*)group_bh
->b_data
;
542 group
->bg_next_group
= cr
->c_blkno
;
543 ocfs2_journal_dirty(handle
, group_bh
);
545 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(main_bm_inode
),
546 main_bm_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
552 if (input
->chain
== le16_to_cpu(cl
->cl_next_free_rec
)) {
553 le16_add_cpu(&cl
->cl_next_free_rec
, 1);
554 memset(cr
, 0, sizeof(struct ocfs2_chain_rec
));
557 cr
->c_blkno
= cpu_to_le64(input
->group
);
558 le32_add_cpu(&cr
->c_total
, input
->clusters
* cl_bpc
);
559 le32_add_cpu(&cr
->c_free
, input
->frees
* cl_bpc
);
561 le32_add_cpu(&fe
->id1
.bitmap1
.i_total
, input
->clusters
*cl_bpc
);
562 le32_add_cpu(&fe
->id1
.bitmap1
.i_used
,
563 (input
->clusters
- input
->frees
) * cl_bpc
);
564 le32_add_cpu(&fe
->i_clusters
, input
->clusters
);
566 ocfs2_journal_dirty(handle
, main_bm_bh
);
568 spin_lock(&OCFS2_I(main_bm_inode
)->ip_lock
);
569 OCFS2_I(main_bm_inode
)->ip_clusters
= le32_to_cpu(fe
->i_clusters
);
570 le64_add_cpu(&fe
->i_size
, input
->clusters
<< osb
->s_clustersize_bits
);
571 spin_unlock(&OCFS2_I(main_bm_inode
)->ip_lock
);
572 i_size_write(main_bm_inode
, le64_to_cpu(fe
->i_size
));
574 ocfs2_update_super_and_backups(main_bm_inode
, input
->clusters
);
577 ocfs2_commit_trans(osb
, handle
);
582 ocfs2_inode_unlock(main_bm_inode
, 1);
585 mutex_unlock(&main_bm_inode
->i_mutex
);