~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/reiserfs/resize.c

Version: ~ [ linux-5.19-rc8 ] ~ [ linux-5.18.14 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.57 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.133 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.207 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.253 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.289 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.324 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
  3  */
  4 
  5 /*
  6  * Written by Alexander Zarochentcev.
  7  *
  8  * The kernel part of the (on-line) reiserfs resizer.
  9  */
 10 
 11 #include <linux/kernel.h>
 12 #include <linux/mm.h>
 13 #include <linux/vmalloc.h>
 14 #include <linux/string.h>
 15 #include <linux/errno.h>
 16 #include "reiserfs.h"
 17 #include <linux/buffer_head.h>
 18 
 19 int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
 20 {
 21         int err = 0;
 22         struct reiserfs_super_block *sb;
 23         struct reiserfs_bitmap_info *bitmap;
 24         struct reiserfs_bitmap_info *info;
 25         struct reiserfs_bitmap_info *old_bitmap = SB_AP_BITMAP(s);
 26         struct buffer_head *bh;
 27         struct reiserfs_transaction_handle th;
 28         unsigned int bmap_nr_new, bmap_nr;
 29         unsigned int block_r_new, block_r;
 30 
 31         struct reiserfs_list_bitmap *jb;
 32         struct reiserfs_list_bitmap jbitmap[JOURNAL_NUM_BITMAPS];
 33 
 34         unsigned long int block_count, free_blocks;
 35         int i;
 36         int copy_size;
 37         int depth;
 38 
 39         sb = SB_DISK_SUPER_BLOCK(s);
 40 
 41         if (SB_BLOCK_COUNT(s) >= block_count_new) {
 42                 printk("can\'t shrink filesystem on-line\n");
 43                 return -EINVAL;
 44         }
 45 
 46         /* check the device size */
 47         depth = reiserfs_write_unlock_nested(s);
 48         bh = sb_bread(s, block_count_new - 1);
 49         reiserfs_write_lock_nested(s, depth);
 50         if (!bh) {
 51                 printk("reiserfs_resize: can\'t read last block\n");
 52                 return -EINVAL;
 53         }
 54         bforget(bh);
 55 
 56         /*
 57          * old disk layout detection; those partitions can be mounted, but
 58          * cannot be resized
 59          */
 60         if (SB_BUFFER_WITH_SB(s)->b_blocknr * SB_BUFFER_WITH_SB(s)->b_size
 61             != REISERFS_DISK_OFFSET_IN_BYTES) {
 62                 printk
 63                     ("reiserfs_resize: unable to resize a reiserfs without distributed bitmap (fs version < 3.5.12)\n");
 64                 return -ENOTSUPP;
 65         }
 66 
 67         /* count used bits in last bitmap block */
 68         block_r = SB_BLOCK_COUNT(s) -
 69                         (reiserfs_bmap_count(s) - 1) * s->s_blocksize * 8;
 70 
 71         /* count bitmap blocks in new fs */
 72         bmap_nr_new = block_count_new / (s->s_blocksize * 8);
 73         block_r_new = block_count_new - bmap_nr_new * s->s_blocksize * 8;
 74         if (block_r_new)
 75                 bmap_nr_new++;
 76         else
 77                 block_r_new = s->s_blocksize * 8;
 78 
 79         /* save old values */
 80         block_count = SB_BLOCK_COUNT(s);
 81         bmap_nr = reiserfs_bmap_count(s);
 82 
 83         /* resizing of reiserfs bitmaps (journal and real), if needed */
 84         if (bmap_nr_new > bmap_nr) {
 85                 /* reallocate journal bitmaps */
 86                 if (reiserfs_allocate_list_bitmaps(s, jbitmap, bmap_nr_new) < 0) {
 87                         printk
 88                             ("reiserfs_resize: unable to allocate memory for journal bitmaps\n");
 89                         return -ENOMEM;
 90                 }
 91                 /*
 92                  * the new journal bitmaps are zero filled, now we copy i
 93                  * the bitmap node pointers from the old journal bitmap
 94                  * structs, and then transfer the new data structures
 95                  * into the journal struct.
 96                  *
 97                  * using the copy_size var below allows this code to work for
 98                  * both shrinking and expanding the FS.
 99                  */
100                 copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr;
101                 copy_size =
102                     copy_size * sizeof(struct reiserfs_list_bitmap_node *);
103                 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
104                         struct reiserfs_bitmap_node **node_tmp;
105                         jb = SB_JOURNAL(s)->j_list_bitmap + i;
106                         memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size);
107 
108                         /*
109                          * just in case vfree schedules on us, copy the new
110                          * pointer into the journal struct before freeing the
111                          * old one
112                          */
113                         node_tmp = jb->bitmaps;
114                         jb->bitmaps = jbitmap[i].bitmaps;
115                         vfree(node_tmp);
116                 }
117 
118                 /*
119                  * allocate additional bitmap blocks, reallocate
120                  * array of bitmap block pointers
121                  */
122                 bitmap =
123                     vzalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new);
124                 if (!bitmap) {
125                         /*
126                          * Journal bitmaps are still supersized, but the
127                          * memory isn't leaked, so I guess it's ok
128                          */
129                         printk("reiserfs_resize: unable to allocate memory.\n");
130                         return -ENOMEM;
131                 }
132                 for (i = 0; i < bmap_nr; i++)
133                         bitmap[i] = old_bitmap[i];
134 
135                 /*
136                  * This doesn't go through the journal, but it doesn't have to.
137                  * The changes are still atomic: We're synced up when the
138                  * journal transaction begins, and the new bitmaps don't
139                  * matter if the transaction fails.
140                  */
141                 for (i = bmap_nr; i < bmap_nr_new; i++) {
142                         int depth;
143                         /*
144                          * don't use read_bitmap_block since it will cache
145                          * the uninitialized bitmap
146                          */
147                         depth = reiserfs_write_unlock_nested(s);
148                         bh = sb_bread(s, i * s->s_blocksize * 8);
149                         reiserfs_write_lock_nested(s, depth);
150                         if (!bh) {
151                                 vfree(bitmap);
152                                 return -EIO;
153                         }
154                         memset(bh->b_data, 0, sb_blocksize(sb));
155                         reiserfs_set_le_bit(0, bh->b_data);
156                         reiserfs_cache_bitmap_metadata(s, bh, bitmap + i);
157 
158                         set_buffer_uptodate(bh);
159                         mark_buffer_dirty(bh);
160                         depth = reiserfs_write_unlock_nested(s);
161                         sync_dirty_buffer(bh);
162                         reiserfs_write_lock_nested(s, depth);
163                         /* update bitmap_info stuff */
164                         bitmap[i].free_count = sb_blocksize(sb) * 8 - 1;
165                         brelse(bh);
166                 }
167                 /* free old bitmap blocks array */
168                 SB_AP_BITMAP(s) = bitmap;
169                 vfree(old_bitmap);
170         }
171 
172         /*
173          * begin transaction, if there was an error, it's fine. Yes, we have
174          * incorrect bitmaps now, but none of it is ever going to touch the
175          * disk anyway.
176          */
177         err = journal_begin(&th, s, 10);
178         if (err)
179                 return err;
180 
181         /* Extend old last bitmap block - new blocks have been made available */
182         info = SB_AP_BITMAP(s) + bmap_nr - 1;
183         bh = reiserfs_read_bitmap_block(s, bmap_nr - 1);
184         if (!bh) {
185                 int jerr = journal_end(&th);
186                 if (jerr)
187                         return jerr;
188                 return -EIO;
189         }
190 
191         reiserfs_prepare_for_journal(s, bh, 1);
192         for (i = block_r; i < s->s_blocksize * 8; i++)
193                 reiserfs_clear_le_bit(i, bh->b_data);
194         info->free_count += s->s_blocksize * 8 - block_r;
195 
196         journal_mark_dirty(&th, bh);
197         brelse(bh);
198 
199         /* Correct new last bitmap block - It may not be full */
200         info = SB_AP_BITMAP(s) + bmap_nr_new - 1;
201         bh = reiserfs_read_bitmap_block(s, bmap_nr_new - 1);
202         if (!bh) {
203                 int jerr = journal_end(&th);
204                 if (jerr)
205                         return jerr;
206                 return -EIO;
207         }
208 
209         reiserfs_prepare_for_journal(s, bh, 1);
210         for (i = block_r_new; i < s->s_blocksize * 8; i++)
211                 reiserfs_set_le_bit(i, bh->b_data);
212         journal_mark_dirty(&th, bh);
213         brelse(bh);
214 
215         info->free_count -= s->s_blocksize * 8 - block_r_new;
216         /* update super */
217         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
218         free_blocks = SB_FREE_BLOCKS(s);
219         PUT_SB_FREE_BLOCKS(s,
220                            free_blocks + (block_count_new - block_count -
221                                           (bmap_nr_new - bmap_nr)));
222         PUT_SB_BLOCK_COUNT(s, block_count_new);
223         PUT_SB_BMAP_NR(s, bmap_would_wrap(bmap_nr_new) ? : bmap_nr_new);
224 
225         journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
226 
227         SB_JOURNAL(s)->j_must_wait = 1;
228         return journal_end(&th);
229 }
230 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp