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