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

TOMOYO Linux Cross Reference
Linux/fs/ocfs2/localalloc.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* -*- mode: c; c-basic-offset: 8; -*-
  2  * vim: noexpandtab sw=8 ts=8 sts=0:
  3  *
  4  * localalloc.c
  5  *
  6  * Node local data allocation
  7  *
  8  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
  9  *
 10  * This program is free software; you can redistribute it and/or
 11  * modify it under the terms of the GNU General Public
 12  * License as published by the Free Software Foundation; either
 13  * version 2 of the License, or (at your option) any later version.
 14  *
 15  * This program is distributed in the hope that it will be useful,
 16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 18  * General Public License for more details.
 19  *
 20  * You should have received a copy of the GNU General Public
 21  * License along with this program; if not, write to the
 22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 23  * Boston, MA 021110-1307, USA.
 24  */
 25 
 26 #include <linux/fs.h>
 27 #include <linux/types.h>
 28 #include <linux/slab.h>
 29 #include <linux/highmem.h>
 30 #include <linux/bitops.h>
 31 
 32 #include <cluster/masklog.h>
 33 
 34 #include "ocfs2.h"
 35 
 36 #include "alloc.h"
 37 #include "blockcheck.h"
 38 #include "dlmglue.h"
 39 #include "inode.h"
 40 #include "journal.h"
 41 #include "localalloc.h"
 42 #include "suballoc.h"
 43 #include "super.h"
 44 #include "sysfile.h"
 45 #include "ocfs2_trace.h"
 46 
 47 #include "buffer_head_io.h"
 48 
 49 #define OCFS2_LOCAL_ALLOC(dinode)       (&((dinode)->id2.i_lab))
 50 
 51 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc);
 52 
 53 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
 54                                              struct ocfs2_dinode *alloc,
 55                                              u32 *numbits,
 56                                              struct ocfs2_alloc_reservation *resv);
 57 
 58 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc);
 59 
 60 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
 61                                     handle_t *handle,
 62                                     struct ocfs2_dinode *alloc,
 63                                     struct inode *main_bm_inode,
 64                                     struct buffer_head *main_bm_bh);
 65 
 66 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
 67                                                 struct ocfs2_alloc_context **ac,
 68                                                 struct inode **bitmap_inode,
 69                                                 struct buffer_head **bitmap_bh);
 70 
 71 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
 72                                         handle_t *handle,
 73                                         struct ocfs2_alloc_context *ac);
 74 
 75 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
 76                                           struct inode *local_alloc_inode);
 77 
 78 /*
 79  * ocfs2_la_default_mb() - determine a default size, in megabytes of
 80  * the local alloc.
 81  *
 82  * Generally, we'd like to pick as large a local alloc as
 83  * possible. Performance on large workloads tends to scale
 84  * proportionally to la size. In addition to that, the reservations
 85  * code functions more efficiently as it can reserve more windows for
 86  * write.
 87  *
 88  * Some things work against us when trying to choose a large local alloc:
 89  *
 90  * - We need to ensure our sizing is picked to leave enough space in
 91  *   group descriptors for other allocations (such as block groups,
 92  *   etc). Picking default sizes which are a multiple of 4 could help
 93  *   - block groups are allocated in 2mb and 4mb chunks.
 94  *
 95  * - Likewise, we don't want to starve other nodes of bits on small
 96  *   file systems. This can easily be taken care of by limiting our
 97  *   default to a reasonable size (256M) on larger cluster sizes.
 98  *
 99  * - Some file systems can't support very large sizes - 4k and 8k in
100  *   particular are limited to less than 128 and 256 megabytes respectively.
101  *
102  * The following reference table shows group descriptor and local
103  * alloc maximums at various cluster sizes (4k blocksize)
104  *
105  * csize: 4K    group: 126M     la: 121M
106  * csize: 8K    group: 252M     la: 243M
107  * csize: 16K   group: 504M     la: 486M
108  * csize: 32K   group: 1008M    la: 972M
109  * csize: 64K   group: 2016M    la: 1944M
110  * csize: 128K  group: 4032M    la: 3888M
111  * csize: 256K  group: 8064M    la: 7776M
112  * csize: 512K  group: 16128M   la: 15552M
113  * csize: 1024K group: 32256M   la: 31104M
114  */
115 #define OCFS2_LA_MAX_DEFAULT_MB 256
116 #define OCFS2_LA_OLD_DEFAULT    8
117 unsigned int ocfs2_la_default_mb(struct ocfs2_super *osb)
118 {
119         unsigned int la_mb;
120         unsigned int gd_mb;
121         unsigned int la_max_mb;
122         unsigned int megs_per_slot;
123         struct super_block *sb = osb->sb;
124 
125         gd_mb = ocfs2_clusters_to_megabytes(osb->sb,
126                 8 * ocfs2_group_bitmap_size(sb, 0, osb->s_feature_incompat));
127 
128         /*
129          * This takes care of files systems with very small group
130          * descriptors - 512 byte blocksize at cluster sizes lower
131          * than 16K and also 1k blocksize with 4k cluster size.
132          */
133         if ((sb->s_blocksize == 512 && osb->s_clustersize <= 8192)
134             || (sb->s_blocksize == 1024 && osb->s_clustersize == 4096))
135                 return OCFS2_LA_OLD_DEFAULT;
136 
137         /*
138          * Leave enough room for some block groups and make the final
139          * value we work from a multiple of 4.
140          */
141         gd_mb -= 16;
142         gd_mb &= 0xFFFFFFFB;
143 
144         la_mb = gd_mb;
145 
146         /*
147          * Keep window sizes down to a reasonable default
148          */
149         if (la_mb > OCFS2_LA_MAX_DEFAULT_MB) {
150                 /*
151                  * Some clustersize / blocksize combinations will have
152                  * given us a larger than OCFS2_LA_MAX_DEFAULT_MB
153                  * default size, but get poor distribution when
154                  * limited to exactly 256 megabytes.
155                  *
156                  * As an example, 16K clustersize at 4K blocksize
157                  * gives us a cluster group size of 504M. Paring the
158                  * local alloc size down to 256 however, would give us
159                  * only one window and around 200MB left in the
160                  * cluster group. Instead, find the first size below
161                  * 256 which would give us an even distribution.
162                  *
163                  * Larger cluster group sizes actually work out pretty
164                  * well when pared to 256, so we don't have to do this
165                  * for any group that fits more than two
166                  * OCFS2_LA_MAX_DEFAULT_MB windows.
167                  */
168                 if (gd_mb > (2 * OCFS2_LA_MAX_DEFAULT_MB))
169                         la_mb = 256;
170                 else {
171                         unsigned int gd_mult = gd_mb;
172 
173                         while (gd_mult > 256)
174                                 gd_mult = gd_mult >> 1;
175 
176                         la_mb = gd_mult;
177                 }
178         }
179 
180         megs_per_slot = osb->osb_clusters_at_boot / osb->max_slots;
181         megs_per_slot = ocfs2_clusters_to_megabytes(osb->sb, megs_per_slot);
182         /* Too many nodes, too few disk clusters. */
183         if (megs_per_slot < la_mb)
184                 la_mb = megs_per_slot;
185 
186         /* We can't store more bits than we can in a block. */
187         la_max_mb = ocfs2_clusters_to_megabytes(osb->sb,
188                                                 ocfs2_local_alloc_size(sb) * 8);
189         if (la_mb > la_max_mb)
190                 la_mb = la_max_mb;
191 
192         return la_mb;
193 }
194 
195 void ocfs2_la_set_sizes(struct ocfs2_super *osb, int requested_mb)
196 {
197         struct super_block *sb = osb->sb;
198         unsigned int la_default_mb = ocfs2_la_default_mb(osb);
199         unsigned int la_max_mb;
200 
201         la_max_mb = ocfs2_clusters_to_megabytes(sb,
202                                                 ocfs2_local_alloc_size(sb) * 8);
203 
204         trace_ocfs2_la_set_sizes(requested_mb, la_max_mb, la_default_mb);
205 
206         if (requested_mb == -1) {
207                 /* No user request - use defaults */
208                 osb->local_alloc_default_bits =
209                         ocfs2_megabytes_to_clusters(sb, la_default_mb);
210         } else if (requested_mb > la_max_mb) {
211                 /* Request is too big, we give the maximum available */
212                 osb->local_alloc_default_bits =
213                         ocfs2_megabytes_to_clusters(sb, la_max_mb);
214         } else {
215                 osb->local_alloc_default_bits =
216                         ocfs2_megabytes_to_clusters(sb, requested_mb);
217         }
218 
219         osb->local_alloc_bits = osb->local_alloc_default_bits;
220 }
221 
222 static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb)
223 {
224         return (osb->local_alloc_state == OCFS2_LA_THROTTLED ||
225                 osb->local_alloc_state == OCFS2_LA_ENABLED);
226 }
227 
228 void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
229                                       unsigned int num_clusters)
230 {
231         spin_lock(&osb->osb_lock);
232         if (osb->local_alloc_state == OCFS2_LA_DISABLED ||
233             osb->local_alloc_state == OCFS2_LA_THROTTLED)
234                 if (num_clusters >= osb->local_alloc_default_bits) {
235                         cancel_delayed_work(&osb->la_enable_wq);
236                         osb->local_alloc_state = OCFS2_LA_ENABLED;
237                 }
238         spin_unlock(&osb->osb_lock);
239 }
240 
241 void ocfs2_la_enable_worker(struct work_struct *work)
242 {
243         struct ocfs2_super *osb =
244                 container_of(work, struct ocfs2_super,
245                              la_enable_wq.work);
246         spin_lock(&osb->osb_lock);
247         osb->local_alloc_state = OCFS2_LA_ENABLED;
248         spin_unlock(&osb->osb_lock);
249 }
250 
251 /*
252  * Tell us whether a given allocation should use the local alloc
253  * file. Otherwise, it has to go to the main bitmap.
254  *
255  * This function does semi-dirty reads of local alloc size and state!
256  * This is ok however, as the values are re-checked once under mutex.
257  */
258 int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
259 {
260         int ret = 0;
261         int la_bits;
262 
263         spin_lock(&osb->osb_lock);
264         la_bits = osb->local_alloc_bits;
265 
266         if (!ocfs2_la_state_enabled(osb))
267                 goto bail;
268 
269         /* la_bits should be at least twice the size (in clusters) of
270          * a new block group. We want to be sure block group
271          * allocations go through the local alloc, so allow an
272          * allocation to take up to half the bitmap. */
273         if (bits > (la_bits / 2))
274                 goto bail;
275 
276         ret = 1;
277 bail:
278         trace_ocfs2_alloc_should_use_local(
279              (unsigned long long)bits, osb->local_alloc_state, la_bits, ret);
280         spin_unlock(&osb->osb_lock);
281         return ret;
282 }
283 
284 int ocfs2_load_local_alloc(struct ocfs2_super *osb)
285 {
286         int status = 0;
287         struct ocfs2_dinode *alloc = NULL;
288         struct buffer_head *alloc_bh = NULL;
289         u32 num_used;
290         struct inode *inode = NULL;
291         struct ocfs2_local_alloc *la;
292 
293         if (osb->local_alloc_bits == 0)
294                 goto bail;
295 
296         if (osb->local_alloc_bits >= osb->bitmap_cpg) {
297                 mlog(ML_NOTICE, "Requested local alloc window %d is larger "
298                      "than max possible %u. Using defaults.\n",
299                      osb->local_alloc_bits, (osb->bitmap_cpg - 1));
300                 osb->local_alloc_bits =
301                         ocfs2_megabytes_to_clusters(osb->sb,
302                                                     ocfs2_la_default_mb(osb));
303         }
304 
305         /* read the alloc off disk */
306         inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE,
307                                             osb->slot_num);
308         if (!inode) {
309                 status = -EINVAL;
310                 mlog_errno(status);
311                 goto bail;
312         }
313 
314         status = ocfs2_read_inode_block_full(inode, &alloc_bh,
315                                              OCFS2_BH_IGNORE_CACHE);
316         if (status < 0) {
317                 mlog_errno(status);
318                 goto bail;
319         }
320 
321         alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
322         la = OCFS2_LOCAL_ALLOC(alloc);
323 
324         if (!(le32_to_cpu(alloc->i_flags) &
325             (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) {
326                 mlog(ML_ERROR, "Invalid local alloc inode, %llu\n",
327                      (unsigned long long)OCFS2_I(inode)->ip_blkno);
328                 status = -EINVAL;
329                 goto bail;
330         }
331 
332         if ((la->la_size == 0) ||
333             (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) {
334                 mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n",
335                      le16_to_cpu(la->la_size));
336                 status = -EINVAL;
337                 goto bail;
338         }
339 
340         /* do a little verification. */
341         num_used = ocfs2_local_alloc_count_bits(alloc);
342 
343         /* hopefully the local alloc has always been recovered before
344          * we load it. */
345         if (num_used
346             || alloc->id1.bitmap1.i_used
347             || alloc->id1.bitmap1.i_total
348             || la->la_bm_off)
349                 mlog(ML_ERROR, "Local alloc hasn't been recovered!\n"
350                      "found = %u, set = %u, taken = %u, off = %u\n",
351                      num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),
352                      le32_to_cpu(alloc->id1.bitmap1.i_total),
353                      OCFS2_LOCAL_ALLOC(alloc)->la_bm_off);
354 
355         osb->local_alloc_bh = alloc_bh;
356         osb->local_alloc_state = OCFS2_LA_ENABLED;
357 
358 bail:
359         if (status < 0)
360                 brelse(alloc_bh);
361         if (inode)
362                 iput(inode);
363 
364         trace_ocfs2_load_local_alloc(osb->local_alloc_bits);
365 
366         if (status)
367                 mlog_errno(status);
368         return status;
369 }
370 
371 /*
372  * return any unused bits to the bitmap and write out a clean
373  * local_alloc.
374  *
375  * local_alloc_bh is optional. If not passed, we will simply use the
376  * one off osb. If you do pass it however, be warned that it *will* be
377  * returned brelse'd and NULL'd out.*/
378 void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
379 {
380         int status;
381         handle_t *handle;
382         struct inode *local_alloc_inode = NULL;
383         struct buffer_head *bh = NULL;
384         struct buffer_head *main_bm_bh = NULL;
385         struct inode *main_bm_inode = NULL;
386         struct ocfs2_dinode *alloc_copy = NULL;
387         struct ocfs2_dinode *alloc = NULL;
388 
389         cancel_delayed_work(&osb->la_enable_wq);
390         flush_workqueue(ocfs2_wq);
391 
392         if (osb->local_alloc_state == OCFS2_LA_UNUSED)
393                 goto out;
394 
395         local_alloc_inode =
396                 ocfs2_get_system_file_inode(osb,
397                                             LOCAL_ALLOC_SYSTEM_INODE,
398                                             osb->slot_num);
399         if (!local_alloc_inode) {
400                 status = -ENOENT;
401                 mlog_errno(status);
402                 goto out;
403         }
404 
405         osb->local_alloc_state = OCFS2_LA_DISABLED;
406 
407         ocfs2_resmap_uninit(&osb->osb_la_resmap);
408 
409         main_bm_inode = ocfs2_get_system_file_inode(osb,
410                                                     GLOBAL_BITMAP_SYSTEM_INODE,
411                                                     OCFS2_INVALID_SLOT);
412         if (!main_bm_inode) {
413                 status = -EINVAL;
414                 mlog_errno(status);
415                 goto out;
416         }
417 
418         mutex_lock(&main_bm_inode->i_mutex);
419 
420         status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
421         if (status < 0) {
422                 mlog_errno(status);
423                 goto out_mutex;
424         }
425 
426         /* WINDOW_MOVE_CREDITS is a bit heavy... */
427         handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
428         if (IS_ERR(handle)) {
429                 mlog_errno(PTR_ERR(handle));
430                 handle = NULL;
431                 goto out_unlock;
432         }
433 
434         bh = osb->local_alloc_bh;
435         alloc = (struct ocfs2_dinode *) bh->b_data;
436 
437         alloc_copy = kmalloc(bh->b_size, GFP_NOFS);
438         if (!alloc_copy) {
439                 status = -ENOMEM;
440                 goto out_commit;
441         }
442         memcpy(alloc_copy, alloc, bh->b_size);
443 
444         status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode),
445                                          bh, OCFS2_JOURNAL_ACCESS_WRITE);
446         if (status < 0) {
447                 mlog_errno(status);
448                 goto out_commit;
449         }
450 
451         ocfs2_clear_local_alloc(alloc);
452         ocfs2_journal_dirty(handle, bh);
453 
454         brelse(bh);
455         osb->local_alloc_bh = NULL;
456         osb->local_alloc_state = OCFS2_LA_UNUSED;
457 
458         status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
459                                           main_bm_inode, main_bm_bh);
460         if (status < 0)
461                 mlog_errno(status);
462 
463 out_commit:
464         ocfs2_commit_trans(osb, handle);
465 
466 out_unlock:
467         brelse(main_bm_bh);
468 
469         ocfs2_inode_unlock(main_bm_inode, 1);
470 
471 out_mutex:
472         mutex_unlock(&main_bm_inode->i_mutex);
473         iput(main_bm_inode);
474 
475 out:
476         if (local_alloc_inode)
477                 iput(local_alloc_inode);
478 
479         kfree(alloc_copy);
480 }
481 
482 /*
483  * We want to free the bitmap bits outside of any recovery context as
484  * we'll need a cluster lock to do so, but we must clear the local
485  * alloc before giving up the recovered nodes journal. To solve this,
486  * we kmalloc a copy of the local alloc before it's change for the
487  * caller to process with ocfs2_complete_local_alloc_recovery
488  */
489 int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
490                                      int slot_num,
491                                      struct ocfs2_dinode **alloc_copy)
492 {
493         int status = 0;
494         struct buffer_head *alloc_bh = NULL;
495         struct inode *inode = NULL;
496         struct ocfs2_dinode *alloc;
497 
498         trace_ocfs2_begin_local_alloc_recovery(slot_num);
499 
500         *alloc_copy = NULL;
501 
502         inode = ocfs2_get_system_file_inode(osb,
503                                             LOCAL_ALLOC_SYSTEM_INODE,
504                                             slot_num);
505         if (!inode) {
506                 status = -EINVAL;
507                 mlog_errno(status);
508                 goto bail;
509         }
510 
511         mutex_lock(&inode->i_mutex);
512 
513         status = ocfs2_read_inode_block_full(inode, &alloc_bh,
514                                              OCFS2_BH_IGNORE_CACHE);
515         if (status < 0) {
516                 mlog_errno(status);
517                 goto bail;
518         }
519 
520         *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL);
521         if (!(*alloc_copy)) {
522                 status = -ENOMEM;
523                 goto bail;
524         }
525         memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size);
526 
527         alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
528         ocfs2_clear_local_alloc(alloc);
529 
530         ocfs2_compute_meta_ecc(osb->sb, alloc_bh->b_data, &alloc->i_check);
531         status = ocfs2_write_block(osb, alloc_bh, INODE_CACHE(inode));
532         if (status < 0)
533                 mlog_errno(status);
534 
535 bail:
536         if (status < 0) {
537                 kfree(*alloc_copy);
538                 *alloc_copy = NULL;
539         }
540 
541         brelse(alloc_bh);
542 
543         if (inode) {
544                 mutex_unlock(&inode->i_mutex);
545                 iput(inode);
546         }
547 
548         if (status)
549                 mlog_errno(status);
550         return status;
551 }
552 
553 /*
554  * Step 2: By now, we've completed the journal recovery, we've stamped
555  * a clean local alloc on disk and dropped the node out of the
556  * recovery map. Dlm locks will no longer stall, so lets clear out the
557  * main bitmap.
558  */
559 int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
560                                         struct ocfs2_dinode *alloc)
561 {
562         int status;
563         handle_t *handle;
564         struct buffer_head *main_bm_bh = NULL;
565         struct inode *main_bm_inode;
566 
567         main_bm_inode = ocfs2_get_system_file_inode(osb,
568                                                     GLOBAL_BITMAP_SYSTEM_INODE,
569                                                     OCFS2_INVALID_SLOT);
570         if (!main_bm_inode) {
571                 status = -EINVAL;
572                 mlog_errno(status);
573                 goto out;
574         }
575 
576         mutex_lock(&main_bm_inode->i_mutex);
577 
578         status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
579         if (status < 0) {
580                 mlog_errno(status);
581                 goto out_mutex;
582         }
583 
584         handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
585         if (IS_ERR(handle)) {
586                 status = PTR_ERR(handle);
587                 handle = NULL;
588                 mlog_errno(status);
589                 goto out_unlock;
590         }
591 
592         /* we want the bitmap change to be recorded on disk asap */
593         handle->h_sync = 1;
594 
595         status = ocfs2_sync_local_to_main(osb, handle, alloc,
596                                           main_bm_inode, main_bm_bh);
597         if (status < 0)
598                 mlog_errno(status);
599 
600         ocfs2_commit_trans(osb, handle);
601 
602 out_unlock:
603         ocfs2_inode_unlock(main_bm_inode, 1);
604 
605 out_mutex:
606         mutex_unlock(&main_bm_inode->i_mutex);
607 
608         brelse(main_bm_bh);
609 
610         iput(main_bm_inode);
611 
612 out:
613         if (!status)
614                 ocfs2_init_steal_slots(osb);
615         if (status)
616                 mlog_errno(status);
617         return status;
618 }
619 
620 /*
621  * make sure we've got at least bits_wanted contiguous bits in the
622  * local alloc. You lose them when you drop i_mutex.
623  *
624  * We will add ourselves to the transaction passed in, but may start
625  * our own in order to shift windows.
626  */
627 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
628                                    u32 bits_wanted,
629                                    struct ocfs2_alloc_context *ac)
630 {
631         int status;
632         struct ocfs2_dinode *alloc;
633         struct inode *local_alloc_inode;
634         unsigned int free_bits;
635 
636         BUG_ON(!ac);
637 
638         local_alloc_inode =
639                 ocfs2_get_system_file_inode(osb,
640                                             LOCAL_ALLOC_SYSTEM_INODE,
641                                             osb->slot_num);
642         if (!local_alloc_inode) {
643                 status = -ENOENT;
644                 mlog_errno(status);
645                 goto bail;
646         }
647 
648         mutex_lock(&local_alloc_inode->i_mutex);
649 
650         /*
651          * We must double check state and allocator bits because
652          * another process may have changed them while holding i_mutex.
653          */
654         spin_lock(&osb->osb_lock);
655         if (!ocfs2_la_state_enabled(osb) ||
656             (bits_wanted > osb->local_alloc_bits)) {
657                 spin_unlock(&osb->osb_lock);
658                 status = -ENOSPC;
659                 goto bail;
660         }
661         spin_unlock(&osb->osb_lock);
662 
663         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
664 
665 #ifdef CONFIG_OCFS2_DEBUG_FS
666         if (le32_to_cpu(alloc->id1.bitmap1.i_used) !=
667             ocfs2_local_alloc_count_bits(alloc)) {
668                 ocfs2_error(osb->sb, "local alloc inode %llu says it has "
669                             "%u free bits, but a count shows %u",
670                             (unsigned long long)le64_to_cpu(alloc->i_blkno),
671                             le32_to_cpu(alloc->id1.bitmap1.i_used),
672                             ocfs2_local_alloc_count_bits(alloc));
673                 status = -EIO;
674                 goto bail;
675         }
676 #endif
677 
678         free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
679                 le32_to_cpu(alloc->id1.bitmap1.i_used);
680         if (bits_wanted > free_bits) {
681                 /* uhoh, window change time. */
682                 status =
683                         ocfs2_local_alloc_slide_window(osb, local_alloc_inode);
684                 if (status < 0) {
685                         if (status != -ENOSPC)
686                                 mlog_errno(status);
687                         goto bail;
688                 }
689 
690                 /*
691                  * Under certain conditions, the window slide code
692                  * might have reduced the number of bits available or
693                  * disabled the the local alloc entirely. Re-check
694                  * here and return -ENOSPC if necessary.
695                  */
696                 status = -ENOSPC;
697                 if (!ocfs2_la_state_enabled(osb))
698                         goto bail;
699 
700                 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
701                         le32_to_cpu(alloc->id1.bitmap1.i_used);
702                 if (bits_wanted > free_bits)
703                         goto bail;
704         }
705 
706         ac->ac_inode = local_alloc_inode;
707         /* We should never use localalloc from another slot */
708         ac->ac_alloc_slot = osb->slot_num;
709         ac->ac_which = OCFS2_AC_USE_LOCAL;
710         get_bh(osb->local_alloc_bh);
711         ac->ac_bh = osb->local_alloc_bh;
712         status = 0;
713 bail:
714         if (status < 0 && local_alloc_inode) {
715                 mutex_unlock(&local_alloc_inode->i_mutex);
716                 iput(local_alloc_inode);
717         }
718 
719         trace_ocfs2_reserve_local_alloc_bits(
720                 (unsigned long long)ac->ac_max_block,
721                 bits_wanted, osb->slot_num, status);
722 
723         if (status)
724                 mlog_errno(status);
725         return status;
726 }
727 
728 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
729                                  handle_t *handle,
730                                  struct ocfs2_alloc_context *ac,
731                                  u32 bits_wanted,
732                                  u32 *bit_off,
733                                  u32 *num_bits)
734 {
735         int status, start;
736         struct inode *local_alloc_inode;
737         void *bitmap;
738         struct ocfs2_dinode *alloc;
739         struct ocfs2_local_alloc *la;
740 
741         BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
742 
743         local_alloc_inode = ac->ac_inode;
744         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
745         la = OCFS2_LOCAL_ALLOC(alloc);
746 
747         start = ocfs2_local_alloc_find_clear_bits(osb, alloc, &bits_wanted,
748                                                   ac->ac_resv);
749         if (start == -1) {
750                 /* TODO: Shouldn't we just BUG here? */
751                 status = -ENOSPC;
752                 mlog_errno(status);
753                 goto bail;
754         }
755 
756         bitmap = la->la_bitmap;
757         *bit_off = le32_to_cpu(la->la_bm_off) + start;
758         *num_bits = bits_wanted;
759 
760         status = ocfs2_journal_access_di(handle,
761                                          INODE_CACHE(local_alloc_inode),
762                                          osb->local_alloc_bh,
763                                          OCFS2_JOURNAL_ACCESS_WRITE);
764         if (status < 0) {
765                 mlog_errno(status);
766                 goto bail;
767         }
768 
769         ocfs2_resmap_claimed_bits(&osb->osb_la_resmap, ac->ac_resv, start,
770                                   bits_wanted);
771 
772         while(bits_wanted--)
773                 ocfs2_set_bit(start++, bitmap);
774 
775         le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits);
776         ocfs2_journal_dirty(handle, osb->local_alloc_bh);
777 
778 bail:
779         if (status)
780                 mlog_errno(status);
781         return status;
782 }
783 
784 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc)
785 {
786         u32 count;
787         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
788 
789         count = memweight(la->la_bitmap, le16_to_cpu(la->la_size));
790 
791         trace_ocfs2_local_alloc_count_bits(count);
792         return count;
793 }
794 
795 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
796                                      struct ocfs2_dinode *alloc,
797                                      u32 *numbits,
798                                      struct ocfs2_alloc_reservation *resv)
799 {
800         int numfound, bitoff, left, startoff, lastzero;
801         int local_resv = 0;
802         struct ocfs2_alloc_reservation r;
803         void *bitmap = NULL;
804         struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap;
805 
806         if (!alloc->id1.bitmap1.i_total) {
807                 bitoff = -1;
808                 goto bail;
809         }
810 
811         if (!resv) {
812                 local_resv = 1;
813                 ocfs2_resv_init_once(&r);
814                 ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP);
815                 resv = &r;
816         }
817 
818         numfound = *numbits;
819         if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) {
820                 if (numfound < *numbits)
821                         *numbits = numfound;
822                 goto bail;
823         }
824 
825         /*
826          * Code error. While reservations are enabled, local
827          * allocation should _always_ go through them.
828          */
829         BUG_ON(osb->osb_resv_level != 0);
830 
831         /*
832          * Reservations are disabled. Handle this the old way.
833          */
834 
835         bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;
836 
837         numfound = bitoff = startoff = 0;
838         lastzero = -1;
839         left = le32_to_cpu(alloc->id1.bitmap1.i_total);
840         while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {
841                 if (bitoff == left) {
842                         /* mlog(0, "bitoff (%d) == left", bitoff); */
843                         break;
844                 }
845                 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
846                    "numfound = %d\n", bitoff, startoff, numfound);*/
847 
848                 /* Ok, we found a zero bit... is it contig. or do we
849                  * start over?*/
850                 if (bitoff == startoff) {
851                         /* we found a zero */
852                         numfound++;
853                         startoff++;
854                 } else {
855                         /* got a zero after some ones */
856                         numfound = 1;
857                         startoff = bitoff+1;
858                 }
859                 /* we got everything we needed */
860                 if (numfound == *numbits) {
861                         /* mlog(0, "Found it all!\n"); */
862                         break;
863                 }
864         }
865 
866         trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound);
867 
868         if (numfound == *numbits)
869                 bitoff = startoff - numfound;
870         else
871                 bitoff = -1;
872 
873 bail:
874         if (local_resv)
875                 ocfs2_resv_discard(resmap, resv);
876 
877         trace_ocfs2_local_alloc_find_clear_bits(*numbits,
878                 le32_to_cpu(alloc->id1.bitmap1.i_total),
879                 bitoff, numfound);
880 
881         return bitoff;
882 }
883 
884 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc)
885 {
886         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
887         int i;
888 
889         alloc->id1.bitmap1.i_total = 0;
890         alloc->id1.bitmap1.i_used = 0;
891         la->la_bm_off = 0;
892         for(i = 0; i < le16_to_cpu(la->la_size); i++)
893                 la->la_bitmap[i] = 0;
894 }
895 
896 #if 0
897 /* turn this on and uncomment below to aid debugging window shifts. */
898 static void ocfs2_verify_zero_bits(unsigned long *bitmap,
899                                    unsigned int start,
900                                    unsigned int count)
901 {
902         unsigned int tmp = count;
903         while(tmp--) {
904                 if (ocfs2_test_bit(start + tmp, bitmap)) {
905                         printk("ocfs2_verify_zero_bits: start = %u, count = "
906                                "%u\n", start, count);
907                         printk("ocfs2_verify_zero_bits: bit %u is set!",
908                                start + tmp);
909                         BUG();
910                 }
911         }
912 }
913 #endif
914 
915 /*
916  * sync the local alloc to main bitmap.
917  *
918  * assumes you've already locked the main bitmap -- the bitmap inode
919  * passed is used for caching.
920  */
921 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
922                                     handle_t *handle,
923                                     struct ocfs2_dinode *alloc,
924                                     struct inode *main_bm_inode,
925                                     struct buffer_head *main_bm_bh)
926 {
927         int status = 0;
928         int bit_off, left, count, start;
929         u64 la_start_blk;
930         u64 blkno;
931         void *bitmap;
932         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
933 
934         trace_ocfs2_sync_local_to_main(
935              le32_to_cpu(alloc->id1.bitmap1.i_total),
936              le32_to_cpu(alloc->id1.bitmap1.i_used));
937 
938         if (!alloc->id1.bitmap1.i_total) {
939                 goto bail;
940         }
941 
942         if (le32_to_cpu(alloc->id1.bitmap1.i_used) ==
943             le32_to_cpu(alloc->id1.bitmap1.i_total)) {
944                 goto bail;
945         }
946 
947         la_start_blk = ocfs2_clusters_to_blocks(osb->sb,
948                                                 le32_to_cpu(la->la_bm_off));
949         bitmap = la->la_bitmap;
950         start = count = bit_off = 0;
951         left = le32_to_cpu(alloc->id1.bitmap1.i_total);
952 
953         while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))
954                != -1) {
955                 if ((bit_off < left) && (bit_off == start)) {
956                         count++;
957                         start++;
958                         continue;
959                 }
960                 if (count) {
961                         blkno = la_start_blk +
962                                 ocfs2_clusters_to_blocks(osb->sb,
963                                                          start - count);
964 
965                         trace_ocfs2_sync_local_to_main_free(
966                              count, start - count,
967                              (unsigned long long)la_start_blk,
968                              (unsigned long long)blkno);
969 
970                         status = ocfs2_release_clusters(handle,
971                                                         main_bm_inode,
972                                                         main_bm_bh, blkno,
973                                                         count);
974                         if (status < 0) {
975                                 mlog_errno(status);
976                                 goto bail;
977                         }
978                 }
979                 if (bit_off >= left)
980                         break;
981                 count = 1;
982                 start = bit_off + 1;
983         }
984 
985 bail:
986         if (status)
987                 mlog_errno(status);
988         return status;
989 }
990 
991 enum ocfs2_la_event {
992         OCFS2_LA_EVENT_SLIDE,           /* Normal window slide. */
993         OCFS2_LA_EVENT_FRAGMENTED,      /* The global bitmap has
994                                          * enough bits theoretically
995                                          * free, but a contiguous
996                                          * allocation could not be
997                                          * found. */
998         OCFS2_LA_EVENT_ENOSPC,          /* Global bitmap doesn't have
999                                          * enough bits free to satisfy
1000                                          * our request. */
1001 };
1002 #define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
1003 /*
1004  * Given an event, calculate the size of our next local alloc window.
1005  *
1006  * This should always be called under i_mutex of the local alloc inode
1007  * so that local alloc disabling doesn't race with processes trying to
1008  * use the allocator.
1009  *
1010  * Returns the state which the local alloc was left in. This value can
1011  * be ignored by some paths.
1012  */
1013 static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
1014                                   enum ocfs2_la_event event)
1015 {
1016         unsigned int bits;
1017         int state;
1018 
1019         spin_lock(&osb->osb_lock);
1020         if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
1021                 WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
1022                 goto out_unlock;
1023         }
1024 
1025         /*
1026          * ENOSPC and fragmentation are treated similarly for now.
1027          */
1028         if (event == OCFS2_LA_EVENT_ENOSPC ||
1029             event == OCFS2_LA_EVENT_FRAGMENTED) {
1030                 /*
1031                  * We ran out of contiguous space in the primary
1032                  * bitmap. Drastically reduce the number of bits used
1033                  * by local alloc until we have to disable it.
1034                  */
1035                 bits = osb->local_alloc_bits >> 1;
1036                 if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
1037                         /*
1038                          * By setting state to THROTTLED, we'll keep
1039                          * the number of local alloc bits used down
1040                          * until an event occurs which would give us
1041                          * reason to assume the bitmap situation might
1042                          * have changed.
1043                          */
1044                         osb->local_alloc_state = OCFS2_LA_THROTTLED;
1045                         osb->local_alloc_bits = bits;
1046                 } else {
1047                         osb->local_alloc_state = OCFS2_LA_DISABLED;
1048                 }
1049                 queue_delayed_work(ocfs2_wq, &osb->la_enable_wq,
1050                                    OCFS2_LA_ENABLE_INTERVAL);
1051                 goto out_unlock;
1052         }
1053 
1054         /*
1055          * Don't increase the size of the local alloc window until we
1056          * know we might be able to fulfill the request. Otherwise, we
1057          * risk bouncing around the global bitmap during periods of
1058          * low space.
1059          */
1060         if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
1061                 osb->local_alloc_bits = osb->local_alloc_default_bits;
1062 
1063 out_unlock:
1064         state = osb->local_alloc_state;
1065         spin_unlock(&osb->osb_lock);
1066 
1067         return state;
1068 }
1069 
1070 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
1071                                                 struct ocfs2_alloc_context **ac,
1072                                                 struct inode **bitmap_inode,
1073                                                 struct buffer_head **bitmap_bh)
1074 {
1075         int status;
1076 
1077         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1078         if (!(*ac)) {
1079                 status = -ENOMEM;
1080                 mlog_errno(status);
1081                 goto bail;
1082         }
1083 
1084 retry_enospc:
1085         (*ac)->ac_bits_wanted = osb->local_alloc_default_bits;
1086         status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1087         if (status == -ENOSPC) {
1088                 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
1089                     OCFS2_LA_DISABLED)
1090                         goto bail;
1091 
1092                 ocfs2_free_ac_resource(*ac);
1093                 memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
1094                 goto retry_enospc;
1095         }
1096         if (status < 0) {
1097                 mlog_errno(status);
1098                 goto bail;
1099         }
1100 
1101         *bitmap_inode = (*ac)->ac_inode;
1102         igrab(*bitmap_inode);
1103         *bitmap_bh = (*ac)->ac_bh;
1104         get_bh(*bitmap_bh);
1105         status = 0;
1106 bail:
1107         if ((status < 0) && *ac) {
1108                 ocfs2_free_alloc_context(*ac);
1109                 *ac = NULL;
1110         }
1111 
1112         if (status)
1113                 mlog_errno(status);
1114         return status;
1115 }
1116 
1117 /*
1118  * pass it the bitmap lock in lock_bh if you have it.
1119  */
1120 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
1121                                         handle_t *handle,
1122                                         struct ocfs2_alloc_context *ac)
1123 {
1124         int status = 0;
1125         u32 cluster_off, cluster_count;
1126         struct ocfs2_dinode *alloc = NULL;
1127         struct ocfs2_local_alloc *la;
1128 
1129         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1130         la = OCFS2_LOCAL_ALLOC(alloc);
1131 
1132         trace_ocfs2_local_alloc_new_window(
1133                 le32_to_cpu(alloc->id1.bitmap1.i_total),
1134                 osb->local_alloc_bits);
1135 
1136         /* Instruct the allocation code to try the most recently used
1137          * cluster group. We'll re-record the group used this pass
1138          * below. */
1139         ac->ac_last_group = osb->la_last_gd;
1140 
1141         /* we used the generic suballoc reserve function, but we set
1142          * everything up nicely, so there's no reason why we can't use
1143          * the more specific cluster api to claim bits. */
1144         status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits,
1145                                       &cluster_off, &cluster_count);
1146         if (status == -ENOSPC) {
1147 retry_enospc:
1148                 /*
1149                  * Note: We could also try syncing the journal here to
1150                  * allow use of any free bits which the current
1151                  * transaction can't give us access to. --Mark
1152                  */
1153                 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
1154                     OCFS2_LA_DISABLED)
1155                         goto bail;
1156 
1157                 ac->ac_bits_wanted = osb->local_alloc_default_bits;
1158                 status = ocfs2_claim_clusters(handle, ac,
1159                                               osb->local_alloc_bits,
1160                                               &cluster_off,
1161                                               &cluster_count);
1162                 if (status == -ENOSPC)
1163                         goto retry_enospc;
1164                 /*
1165                  * We only shrunk the *minimum* number of in our
1166                  * request - it's entirely possible that the allocator
1167                  * might give us more than we asked for.
1168                  */
1169                 if (status == 0) {
1170                         spin_lock(&osb->osb_lock);
1171                         osb->local_alloc_bits = cluster_count;
1172                         spin_unlock(&osb->osb_lock);
1173                 }
1174         }
1175         if (status < 0) {
1176                 if (status != -ENOSPC)
1177                         mlog_errno(status);
1178                 goto bail;
1179         }
1180 
1181         osb->la_last_gd = ac->ac_last_group;
1182 
1183         la->la_bm_off = cpu_to_le32(cluster_off);
1184         alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count);
1185         /* just in case... In the future when we find space ourselves,
1186          * we don't have to get all contiguous -- but we'll have to
1187          * set all previously used bits in bitmap and update
1188          * la_bits_set before setting the bits in the main bitmap. */
1189         alloc->id1.bitmap1.i_used = 0;
1190         memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0,
1191                le16_to_cpu(la->la_size));
1192 
1193         ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count,
1194                              OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);
1195 
1196         trace_ocfs2_local_alloc_new_window_result(
1197                 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off,
1198                 le32_to_cpu(alloc->id1.bitmap1.i_total));
1199 
1200 bail:
1201         if (status)
1202                 mlog_errno(status);
1203         return status;
1204 }
1205 
1206 /* Note that we do *NOT* lock the local alloc inode here as
1207  * it's been locked already for us. */
1208 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
1209                                           struct inode *local_alloc_inode)
1210 {
1211         int status = 0;
1212         struct buffer_head *main_bm_bh = NULL;
1213         struct inode *main_bm_inode = NULL;
1214         handle_t *handle = NULL;
1215         struct ocfs2_dinode *alloc;
1216         struct ocfs2_dinode *alloc_copy = NULL;
1217         struct ocfs2_alloc_context *ac = NULL;
1218 
1219         ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);
1220 
1221         /* This will lock the main bitmap for us. */
1222         status = ocfs2_local_alloc_reserve_for_window(osb,
1223                                                       &ac,
1224                                                       &main_bm_inode,
1225                                                       &main_bm_bh);
1226         if (status < 0) {
1227                 if (status != -ENOSPC)
1228                         mlog_errno(status);
1229                 goto bail;
1230         }
1231 
1232         handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
1233         if (IS_ERR(handle)) {
1234                 status = PTR_ERR(handle);
1235                 handle = NULL;
1236                 mlog_errno(status);
1237                 goto bail;
1238         }
1239 
1240         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1241 
1242         /* We want to clear the local alloc before doing anything
1243          * else, so that if we error later during this operation,
1244          * local alloc shutdown won't try to double free main bitmap
1245          * bits. Make a copy so the sync function knows which bits to
1246          * free. */
1247         alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS);
1248         if (!alloc_copy) {
1249                 status = -ENOMEM;
1250                 mlog_errno(status);
1251                 goto bail;
1252         }
1253         memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
1254 
1255         status = ocfs2_journal_access_di(handle,
1256                                          INODE_CACHE(local_alloc_inode),
1257                                          osb->local_alloc_bh,
1258                                          OCFS2_JOURNAL_ACCESS_WRITE);
1259         if (status < 0) {
1260                 mlog_errno(status);
1261                 goto bail;
1262         }
1263 
1264         ocfs2_clear_local_alloc(alloc);
1265         ocfs2_journal_dirty(handle, osb->local_alloc_bh);
1266 
1267         status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
1268                                           main_bm_inode, main_bm_bh);
1269         if (status < 0) {
1270                 mlog_errno(status);
1271                 goto bail;
1272         }
1273 
1274         status = ocfs2_local_alloc_new_window(osb, handle, ac);
1275         if (status < 0) {
1276                 if (status != -ENOSPC)
1277                         mlog_errno(status);
1278                 goto bail;
1279         }
1280 
1281         atomic_inc(&osb->alloc_stats.moves);
1282 
1283 bail:
1284         if (handle)
1285                 ocfs2_commit_trans(osb, handle);
1286 
1287         brelse(main_bm_bh);
1288 
1289         if (main_bm_inode)
1290                 iput(main_bm_inode);
1291 
1292         kfree(alloc_copy);
1293 
1294         if (ac)
1295                 ocfs2_free_alloc_context(ac);
1296 
1297         if (status)
1298                 mlog_errno(status);
1299         return status;
1300 }
1301 
1302 

~ [ 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