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

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

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ 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.85 ] ~ [ 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-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 int ocfs2_free_local_alloc_bits(struct ocfs2_super *osb,
785                                 handle_t *handle,
786                                 struct ocfs2_alloc_context *ac,
787                                 u32 bit_off,
788                                 u32 num_bits)
789 {
790         int status, start;
791         u32 clear_bits;
792         struct inode *local_alloc_inode;
793         void *bitmap;
794         struct ocfs2_dinode *alloc;
795         struct ocfs2_local_alloc *la;
796 
797         BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
798 
799         local_alloc_inode = ac->ac_inode;
800         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
801         la = OCFS2_LOCAL_ALLOC(alloc);
802 
803         bitmap = la->la_bitmap;
804         start = bit_off - le32_to_cpu(la->la_bm_off);
805         clear_bits = num_bits;
806 
807         status = ocfs2_journal_access_di(handle,
808                         INODE_CACHE(local_alloc_inode),
809                         osb->local_alloc_bh,
810                         OCFS2_JOURNAL_ACCESS_WRITE);
811         if (status < 0) {
812                 mlog_errno(status);
813                 goto bail;
814         }
815 
816         while (clear_bits--)
817                 ocfs2_clear_bit(start++, bitmap);
818 
819         le32_add_cpu(&alloc->id1.bitmap1.i_used, -num_bits);
820         ocfs2_journal_dirty(handle, osb->local_alloc_bh);
821 
822 bail:
823         return status;
824 }
825 
826 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc)
827 {
828         u32 count;
829         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
830 
831         count = memweight(la->la_bitmap, le16_to_cpu(la->la_size));
832 
833         trace_ocfs2_local_alloc_count_bits(count);
834         return count;
835 }
836 
837 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
838                                      struct ocfs2_dinode *alloc,
839                                      u32 *numbits,
840                                      struct ocfs2_alloc_reservation *resv)
841 {
842         int numfound, bitoff, left, startoff, lastzero;
843         int local_resv = 0;
844         struct ocfs2_alloc_reservation r;
845         void *bitmap = NULL;
846         struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap;
847 
848         if (!alloc->id1.bitmap1.i_total) {
849                 bitoff = -1;
850                 goto bail;
851         }
852 
853         if (!resv) {
854                 local_resv = 1;
855                 ocfs2_resv_init_once(&r);
856                 ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP);
857                 resv = &r;
858         }
859 
860         numfound = *numbits;
861         if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) {
862                 if (numfound < *numbits)
863                         *numbits = numfound;
864                 goto bail;
865         }
866 
867         /*
868          * Code error. While reservations are enabled, local
869          * allocation should _always_ go through them.
870          */
871         BUG_ON(osb->osb_resv_level != 0);
872 
873         /*
874          * Reservations are disabled. Handle this the old way.
875          */
876 
877         bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;
878 
879         numfound = bitoff = startoff = 0;
880         lastzero = -1;
881         left = le32_to_cpu(alloc->id1.bitmap1.i_total);
882         while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {
883                 if (bitoff == left) {
884                         /* mlog(0, "bitoff (%d) == left", bitoff); */
885                         break;
886                 }
887                 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
888                    "numfound = %d\n", bitoff, startoff, numfound);*/
889 
890                 /* Ok, we found a zero bit... is it contig. or do we
891                  * start over?*/
892                 if (bitoff == startoff) {
893                         /* we found a zero */
894                         numfound++;
895                         startoff++;
896                 } else {
897                         /* got a zero after some ones */
898                         numfound = 1;
899                         startoff = bitoff+1;
900                 }
901                 /* we got everything we needed */
902                 if (numfound == *numbits) {
903                         /* mlog(0, "Found it all!\n"); */
904                         break;
905                 }
906         }
907 
908         trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound);
909 
910         if (numfound == *numbits)
911                 bitoff = startoff - numfound;
912         else
913                 bitoff = -1;
914 
915 bail:
916         if (local_resv)
917                 ocfs2_resv_discard(resmap, resv);
918 
919         trace_ocfs2_local_alloc_find_clear_bits(*numbits,
920                 le32_to_cpu(alloc->id1.bitmap1.i_total),
921                 bitoff, numfound);
922 
923         return bitoff;
924 }
925 
926 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc)
927 {
928         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
929         int i;
930 
931         alloc->id1.bitmap1.i_total = 0;
932         alloc->id1.bitmap1.i_used = 0;
933         la->la_bm_off = 0;
934         for(i = 0; i < le16_to_cpu(la->la_size); i++)
935                 la->la_bitmap[i] = 0;
936 }
937 
938 #if 0
939 /* turn this on and uncomment below to aid debugging window shifts. */
940 static void ocfs2_verify_zero_bits(unsigned long *bitmap,
941                                    unsigned int start,
942                                    unsigned int count)
943 {
944         unsigned int tmp = count;
945         while(tmp--) {
946                 if (ocfs2_test_bit(start + tmp, bitmap)) {
947                         printk("ocfs2_verify_zero_bits: start = %u, count = "
948                                "%u\n", start, count);
949                         printk("ocfs2_verify_zero_bits: bit %u is set!",
950                                start + tmp);
951                         BUG();
952                 }
953         }
954 }
955 #endif
956 
957 /*
958  * sync the local alloc to main bitmap.
959  *
960  * assumes you've already locked the main bitmap -- the bitmap inode
961  * passed is used for caching.
962  */
963 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
964                                     handle_t *handle,
965                                     struct ocfs2_dinode *alloc,
966                                     struct inode *main_bm_inode,
967                                     struct buffer_head *main_bm_bh)
968 {
969         int status = 0;
970         int bit_off, left, count, start;
971         u64 la_start_blk;
972         u64 blkno;
973         void *bitmap;
974         struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
975 
976         trace_ocfs2_sync_local_to_main(
977              le32_to_cpu(alloc->id1.bitmap1.i_total),
978              le32_to_cpu(alloc->id1.bitmap1.i_used));
979 
980         if (!alloc->id1.bitmap1.i_total) {
981                 goto bail;
982         }
983 
984         if (le32_to_cpu(alloc->id1.bitmap1.i_used) ==
985             le32_to_cpu(alloc->id1.bitmap1.i_total)) {
986                 goto bail;
987         }
988 
989         la_start_blk = ocfs2_clusters_to_blocks(osb->sb,
990                                                 le32_to_cpu(la->la_bm_off));
991         bitmap = la->la_bitmap;
992         start = count = bit_off = 0;
993         left = le32_to_cpu(alloc->id1.bitmap1.i_total);
994 
995         while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))
996                != -1) {
997                 if ((bit_off < left) && (bit_off == start)) {
998                         count++;
999                         start++;
1000                         continue;
1001                 }
1002                 if (count) {
1003                         blkno = la_start_blk +
1004                                 ocfs2_clusters_to_blocks(osb->sb,
1005                                                          start - count);
1006 
1007                         trace_ocfs2_sync_local_to_main_free(
1008                              count, start - count,
1009                              (unsigned long long)la_start_blk,
1010                              (unsigned long long)blkno);
1011 
1012                         status = ocfs2_release_clusters(handle,
1013                                                         main_bm_inode,
1014                                                         main_bm_bh, blkno,
1015                                                         count);
1016                         if (status < 0) {
1017                                 mlog_errno(status);
1018                                 goto bail;
1019                         }
1020                 }
1021                 if (bit_off >= left)
1022                         break;
1023                 count = 1;
1024                 start = bit_off + 1;
1025         }
1026 
1027 bail:
1028         if (status)
1029                 mlog_errno(status);
1030         return status;
1031 }
1032 
1033 enum ocfs2_la_event {
1034         OCFS2_LA_EVENT_SLIDE,           /* Normal window slide. */
1035         OCFS2_LA_EVENT_FRAGMENTED,      /* The global bitmap has
1036                                          * enough bits theoretically
1037                                          * free, but a contiguous
1038                                          * allocation could not be
1039                                          * found. */
1040         OCFS2_LA_EVENT_ENOSPC,          /* Global bitmap doesn't have
1041                                          * enough bits free to satisfy
1042                                          * our request. */
1043 };
1044 #define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
1045 /*
1046  * Given an event, calculate the size of our next local alloc window.
1047  *
1048  * This should always be called under i_mutex of the local alloc inode
1049  * so that local alloc disabling doesn't race with processes trying to
1050  * use the allocator.
1051  *
1052  * Returns the state which the local alloc was left in. This value can
1053  * be ignored by some paths.
1054  */
1055 static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
1056                                   enum ocfs2_la_event event)
1057 {
1058         unsigned int bits;
1059         int state;
1060 
1061         spin_lock(&osb->osb_lock);
1062         if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
1063                 WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
1064                 goto out_unlock;
1065         }
1066 
1067         /*
1068          * ENOSPC and fragmentation are treated similarly for now.
1069          */
1070         if (event == OCFS2_LA_EVENT_ENOSPC ||
1071             event == OCFS2_LA_EVENT_FRAGMENTED) {
1072                 /*
1073                  * We ran out of contiguous space in the primary
1074                  * bitmap. Drastically reduce the number of bits used
1075                  * by local alloc until we have to disable it.
1076                  */
1077                 bits = osb->local_alloc_bits >> 1;
1078                 if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
1079                         /*
1080                          * By setting state to THROTTLED, we'll keep
1081                          * the number of local alloc bits used down
1082                          * until an event occurs which would give us
1083                          * reason to assume the bitmap situation might
1084                          * have changed.
1085                          */
1086                         osb->local_alloc_state = OCFS2_LA_THROTTLED;
1087                         osb->local_alloc_bits = bits;
1088                 } else {
1089                         osb->local_alloc_state = OCFS2_LA_DISABLED;
1090                 }
1091                 queue_delayed_work(ocfs2_wq, &osb->la_enable_wq,
1092                                    OCFS2_LA_ENABLE_INTERVAL);
1093                 goto out_unlock;
1094         }
1095 
1096         /*
1097          * Don't increase the size of the local alloc window until we
1098          * know we might be able to fulfill the request. Otherwise, we
1099          * risk bouncing around the global bitmap during periods of
1100          * low space.
1101          */
1102         if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
1103                 osb->local_alloc_bits = osb->local_alloc_default_bits;
1104 
1105 out_unlock:
1106         state = osb->local_alloc_state;
1107         spin_unlock(&osb->osb_lock);
1108 
1109         return state;
1110 }
1111 
1112 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
1113                                                 struct ocfs2_alloc_context **ac,
1114                                                 struct inode **bitmap_inode,
1115                                                 struct buffer_head **bitmap_bh)
1116 {
1117         int status;
1118 
1119         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1120         if (!(*ac)) {
1121                 status = -ENOMEM;
1122                 mlog_errno(status);
1123                 goto bail;
1124         }
1125 
1126 retry_enospc:
1127         (*ac)->ac_bits_wanted = osb->local_alloc_bits;
1128         status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1129         if (status == -ENOSPC) {
1130                 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
1131                     OCFS2_LA_DISABLED)
1132                         goto bail;
1133 
1134                 ocfs2_free_ac_resource(*ac);
1135                 memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
1136                 goto retry_enospc;
1137         }
1138         if (status < 0) {
1139                 mlog_errno(status);
1140                 goto bail;
1141         }
1142 
1143         *bitmap_inode = (*ac)->ac_inode;
1144         igrab(*bitmap_inode);
1145         *bitmap_bh = (*ac)->ac_bh;
1146         get_bh(*bitmap_bh);
1147         status = 0;
1148 bail:
1149         if ((status < 0) && *ac) {
1150                 ocfs2_free_alloc_context(*ac);
1151                 *ac = NULL;
1152         }
1153 
1154         if (status)
1155                 mlog_errno(status);
1156         return status;
1157 }
1158 
1159 /*
1160  * pass it the bitmap lock in lock_bh if you have it.
1161  */
1162 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
1163                                         handle_t *handle,
1164                                         struct ocfs2_alloc_context *ac)
1165 {
1166         int status = 0;
1167         u32 cluster_off, cluster_count;
1168         struct ocfs2_dinode *alloc = NULL;
1169         struct ocfs2_local_alloc *la;
1170 
1171         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1172         la = OCFS2_LOCAL_ALLOC(alloc);
1173 
1174         trace_ocfs2_local_alloc_new_window(
1175                 le32_to_cpu(alloc->id1.bitmap1.i_total),
1176                 osb->local_alloc_bits);
1177 
1178         /* Instruct the allocation code to try the most recently used
1179          * cluster group. We'll re-record the group used this pass
1180          * below. */
1181         ac->ac_last_group = osb->la_last_gd;
1182 
1183         /* we used the generic suballoc reserve function, but we set
1184          * everything up nicely, so there's no reason why we can't use
1185          * the more specific cluster api to claim bits. */
1186         status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits,
1187                                       &cluster_off, &cluster_count);
1188         if (status == -ENOSPC) {
1189 retry_enospc:
1190                 /*
1191                  * Note: We could also try syncing the journal here to
1192                  * allow use of any free bits which the current
1193                  * transaction can't give us access to. --Mark
1194                  */
1195                 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
1196                     OCFS2_LA_DISABLED)
1197                         goto bail;
1198 
1199                 ac->ac_bits_wanted = osb->local_alloc_bits;
1200                 status = ocfs2_claim_clusters(handle, ac,
1201                                               osb->local_alloc_bits,
1202                                               &cluster_off,
1203                                               &cluster_count);
1204                 if (status == -ENOSPC)
1205                         goto retry_enospc;
1206                 /*
1207                  * We only shrunk the *minimum* number of in our
1208                  * request - it's entirely possible that the allocator
1209                  * might give us more than we asked for.
1210                  */
1211                 if (status == 0) {
1212                         spin_lock(&osb->osb_lock);
1213                         osb->local_alloc_bits = cluster_count;
1214                         spin_unlock(&osb->osb_lock);
1215                 }
1216         }
1217         if (status < 0) {
1218                 if (status != -ENOSPC)
1219                         mlog_errno(status);
1220                 goto bail;
1221         }
1222 
1223         osb->la_last_gd = ac->ac_last_group;
1224 
1225         la->la_bm_off = cpu_to_le32(cluster_off);
1226         alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count);
1227         /* just in case... In the future when we find space ourselves,
1228          * we don't have to get all contiguous -- but we'll have to
1229          * set all previously used bits in bitmap and update
1230          * la_bits_set before setting the bits in the main bitmap. */
1231         alloc->id1.bitmap1.i_used = 0;
1232         memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0,
1233                le16_to_cpu(la->la_size));
1234 
1235         ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count,
1236                              OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);
1237 
1238         trace_ocfs2_local_alloc_new_window_result(
1239                 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off,
1240                 le32_to_cpu(alloc->id1.bitmap1.i_total));
1241 
1242 bail:
1243         if (status)
1244                 mlog_errno(status);
1245         return status;
1246 }
1247 
1248 /* Note that we do *NOT* lock the local alloc inode here as
1249  * it's been locked already for us. */
1250 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
1251                                           struct inode *local_alloc_inode)
1252 {
1253         int status = 0;
1254         struct buffer_head *main_bm_bh = NULL;
1255         struct inode *main_bm_inode = NULL;
1256         handle_t *handle = NULL;
1257         struct ocfs2_dinode *alloc;
1258         struct ocfs2_dinode *alloc_copy = NULL;
1259         struct ocfs2_alloc_context *ac = NULL;
1260 
1261         ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);
1262 
1263         /* This will lock the main bitmap for us. */
1264         status = ocfs2_local_alloc_reserve_for_window(osb,
1265                                                       &ac,
1266                                                       &main_bm_inode,
1267                                                       &main_bm_bh);
1268         if (status < 0) {
1269                 if (status != -ENOSPC)
1270                         mlog_errno(status);
1271                 goto bail;
1272         }
1273 
1274         handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
1275         if (IS_ERR(handle)) {
1276                 status = PTR_ERR(handle);
1277                 handle = NULL;
1278                 mlog_errno(status);
1279                 goto bail;
1280         }
1281 
1282         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1283 
1284         /* We want to clear the local alloc before doing anything
1285          * else, so that if we error later during this operation,
1286          * local alloc shutdown won't try to double free main bitmap
1287          * bits. Make a copy so the sync function knows which bits to
1288          * free. */
1289         alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS);
1290         if (!alloc_copy) {
1291                 status = -ENOMEM;
1292                 mlog_errno(status);
1293                 goto bail;
1294         }
1295         memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
1296 
1297         status = ocfs2_journal_access_di(handle,
1298                                          INODE_CACHE(local_alloc_inode),
1299                                          osb->local_alloc_bh,
1300                                          OCFS2_JOURNAL_ACCESS_WRITE);
1301         if (status < 0) {
1302                 mlog_errno(status);
1303                 goto bail;
1304         }
1305 
1306         ocfs2_clear_local_alloc(alloc);
1307         ocfs2_journal_dirty(handle, osb->local_alloc_bh);
1308 
1309         status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
1310                                           main_bm_inode, main_bm_bh);
1311         if (status < 0) {
1312                 mlog_errno(status);
1313                 goto bail;
1314         }
1315 
1316         status = ocfs2_local_alloc_new_window(osb, handle, ac);
1317         if (status < 0) {
1318                 if (status != -ENOSPC)
1319                         mlog_errno(status);
1320                 goto bail;
1321         }
1322 
1323         atomic_inc(&osb->alloc_stats.moves);
1324 
1325 bail:
1326         if (handle)
1327                 ocfs2_commit_trans(osb, handle);
1328 
1329         brelse(main_bm_bh);
1330 
1331         if (main_bm_inode)
1332                 iput(main_bm_inode);
1333 
1334         kfree(alloc_copy);
1335 
1336         if (ac)
1337                 ocfs2_free_alloc_context(ac);
1338 
1339         if (status)
1340                 mlog_errno(status);
1341         return status;
1342 }
1343 
1344 

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