include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-3.10.git] / drivers / block / drbd / drbd_bitmap.c
1 /*
2    drbd_bitmap.c
3
4    This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6    Copyright (C) 2004-2008, LINBIT Information Technologies GmbH.
7    Copyright (C) 2004-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8    Copyright (C) 2004-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10    drbd is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2, or (at your option)
13    any later version.
14
15    drbd 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
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with drbd; see the file COPYING.  If not, write to
22    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 #include <linux/bitops.h>
26 #include <linux/vmalloc.h>
27 #include <linux/string.h>
28 #include <linux/drbd.h>
29 #include <linux/slab.h>
30 #include <asm/kmap_types.h>
31 #include "drbd_int.h"
32
33 /* OPAQUE outside this file!
34  * interface defined in drbd_int.h
35
36  * convention:
37  * function name drbd_bm_... => used elsewhere, "public".
38  * function name      bm_... => internal to implementation, "private".
39
40  * Note that since find_first_bit returns int, at the current granularity of
41  * the bitmap (4KB per byte), this implementation "only" supports up to
42  * 1<<(32+12) == 16 TB...
43  */
44
45 /*
46  * NOTE
47  *  Access to the *bm_pages is protected by bm_lock.
48  *  It is safe to read the other members within the lock.
49  *
50  *  drbd_bm_set_bits is called from bio_endio callbacks,
51  *  We may be called with irq already disabled,
52  *  so we need spin_lock_irqsave().
53  *  And we need the kmap_atomic.
54  */
55 struct drbd_bitmap {
56         struct page **bm_pages;
57         spinlock_t bm_lock;
58         /* WARNING unsigned long bm_*:
59          * 32bit number of bit offset is just enough for 512 MB bitmap.
60          * it will blow up if we make the bitmap bigger...
61          * not that it makes much sense to have a bitmap that large,
62          * rather change the granularity to 16k or 64k or something.
63          * (that implies other problems, however...)
64          */
65         unsigned long bm_set;       /* nr of set bits; THINK maybe atomic_t? */
66         unsigned long bm_bits;
67         size_t   bm_words;
68         size_t   bm_number_of_pages;
69         sector_t bm_dev_capacity;
70         struct semaphore bm_change; /* serializes resize operations */
71
72         atomic_t bm_async_io;
73         wait_queue_head_t bm_io_wait;
74
75         unsigned long  bm_flags;
76
77         /* debugging aid, in case we are still racy somewhere */
78         char          *bm_why;
79         struct task_struct *bm_task;
80 };
81
82 /* definition of bits in bm_flags */
83 #define BM_LOCKED       0
84 #define BM_MD_IO_ERROR  1
85 #define BM_P_VMALLOCED  2
86
87 static int bm_is_locked(struct drbd_bitmap *b)
88 {
89         return test_bit(BM_LOCKED, &b->bm_flags);
90 }
91
92 #define bm_print_lock_info(m) __bm_print_lock_info(m, __func__)
93 static void __bm_print_lock_info(struct drbd_conf *mdev, const char *func)
94 {
95         struct drbd_bitmap *b = mdev->bitmap;
96         if (!__ratelimit(&drbd_ratelimit_state))
97                 return;
98         dev_err(DEV, "FIXME %s in %s, bitmap locked for '%s' by %s\n",
99             current == mdev->receiver.task ? "receiver" :
100             current == mdev->asender.task  ? "asender"  :
101             current == mdev->worker.task   ? "worker"   : current->comm,
102             func, b->bm_why ?: "?",
103             b->bm_task == mdev->receiver.task ? "receiver" :
104             b->bm_task == mdev->asender.task  ? "asender"  :
105             b->bm_task == mdev->worker.task   ? "worker"   : "?");
106 }
107
108 void drbd_bm_lock(struct drbd_conf *mdev, char *why)
109 {
110         struct drbd_bitmap *b = mdev->bitmap;
111         int trylock_failed;
112
113         if (!b) {
114                 dev_err(DEV, "FIXME no bitmap in drbd_bm_lock!?\n");
115                 return;
116         }
117
118         trylock_failed = down_trylock(&b->bm_change);
119
120         if (trylock_failed) {
121                 dev_warn(DEV, "%s going to '%s' but bitmap already locked for '%s' by %s\n",
122                     current == mdev->receiver.task ? "receiver" :
123                     current == mdev->asender.task  ? "asender"  :
124                     current == mdev->worker.task   ? "worker"   : current->comm,
125                     why, b->bm_why ?: "?",
126                     b->bm_task == mdev->receiver.task ? "receiver" :
127                     b->bm_task == mdev->asender.task  ? "asender"  :
128                     b->bm_task == mdev->worker.task   ? "worker"   : "?");
129                 down(&b->bm_change);
130         }
131         if (__test_and_set_bit(BM_LOCKED, &b->bm_flags))
132                 dev_err(DEV, "FIXME bitmap already locked in bm_lock\n");
133
134         b->bm_why  = why;
135         b->bm_task = current;
136 }
137
138 void drbd_bm_unlock(struct drbd_conf *mdev)
139 {
140         struct drbd_bitmap *b = mdev->bitmap;
141         if (!b) {
142                 dev_err(DEV, "FIXME no bitmap in drbd_bm_unlock!?\n");
143                 return;
144         }
145
146         if (!__test_and_clear_bit(BM_LOCKED, &mdev->bitmap->bm_flags))
147                 dev_err(DEV, "FIXME bitmap not locked in bm_unlock\n");
148
149         b->bm_why  = NULL;
150         b->bm_task = NULL;
151         up(&b->bm_change);
152 }
153
154 /* word offset to long pointer */
155 static unsigned long *__bm_map_paddr(struct drbd_bitmap *b, unsigned long offset, const enum km_type km)
156 {
157         struct page *page;
158         unsigned long page_nr;
159
160         /* page_nr = (word*sizeof(long)) >> PAGE_SHIFT; */
161         page_nr = offset >> (PAGE_SHIFT - LN2_BPL + 3);
162         BUG_ON(page_nr >= b->bm_number_of_pages);
163         page = b->bm_pages[page_nr];
164
165         return (unsigned long *) kmap_atomic(page, km);
166 }
167
168 static unsigned long * bm_map_paddr(struct drbd_bitmap *b, unsigned long offset)
169 {
170         return __bm_map_paddr(b, offset, KM_IRQ1);
171 }
172
173 static void __bm_unmap(unsigned long *p_addr, const enum km_type km)
174 {
175         kunmap_atomic(p_addr, km);
176 };
177
178 static void bm_unmap(unsigned long *p_addr)
179 {
180         return __bm_unmap(p_addr, KM_IRQ1);
181 }
182
183 /* long word offset of _bitmap_ sector */
184 #define S2W(s)  ((s)<<(BM_EXT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL))
185 /* word offset from start of bitmap to word number _in_page_
186  * modulo longs per page
187 #define MLPP(X) ((X) % (PAGE_SIZE/sizeof(long))
188  hm, well, Philipp thinks gcc might not optimze the % into & (... - 1)
189  so do it explicitly:
190  */
191 #define MLPP(X) ((X) & ((PAGE_SIZE/sizeof(long))-1))
192
193 /* Long words per page */
194 #define LWPP (PAGE_SIZE/sizeof(long))
195
196 /*
197  * actually most functions herein should take a struct drbd_bitmap*, not a
198  * struct drbd_conf*, but for the debug macros I like to have the mdev around
199  * to be able to report device specific.
200  */
201
202 static void bm_free_pages(struct page **pages, unsigned long number)
203 {
204         unsigned long i;
205         if (!pages)
206                 return;
207
208         for (i = 0; i < number; i++) {
209                 if (!pages[i]) {
210                         printk(KERN_ALERT "drbd: bm_free_pages tried to free "
211                                           "a NULL pointer; i=%lu n=%lu\n",
212                                           i, number);
213                         continue;
214                 }
215                 __free_page(pages[i]);
216                 pages[i] = NULL;
217         }
218 }
219
220 static void bm_vk_free(void *ptr, int v)
221 {
222         if (v)
223                 vfree(ptr);
224         else
225                 kfree(ptr);
226 }
227
228 /*
229  * "have" and "want" are NUMBER OF PAGES.
230  */
231 static struct page **bm_realloc_pages(struct drbd_bitmap *b, unsigned long want)
232 {
233         struct page **old_pages = b->bm_pages;
234         struct page **new_pages, *page;
235         unsigned int i, bytes, vmalloced = 0;
236         unsigned long have = b->bm_number_of_pages;
237
238         BUG_ON(have == 0 && old_pages != NULL);
239         BUG_ON(have != 0 && old_pages == NULL);
240
241         if (have == want)
242                 return old_pages;
243
244         /* Trying kmalloc first, falling back to vmalloc.
245          * GFP_KERNEL is ok, as this is done when a lower level disk is
246          * "attached" to the drbd.  Context is receiver thread or cqueue
247          * thread.  As we have no disk yet, we are not in the IO path,
248          * not even the IO path of the peer. */
249         bytes = sizeof(struct page *)*want;
250         new_pages = kmalloc(bytes, GFP_KERNEL);
251         if (!new_pages) {
252                 new_pages = vmalloc(bytes);
253                 if (!new_pages)
254                         return NULL;
255                 vmalloced = 1;
256         }
257
258         memset(new_pages, 0, bytes);
259         if (want >= have) {
260                 for (i = 0; i < have; i++)
261                         new_pages[i] = old_pages[i];
262                 for (; i < want; i++) {
263                         page = alloc_page(GFP_HIGHUSER);
264                         if (!page) {
265                                 bm_free_pages(new_pages + have, i - have);
266                                 bm_vk_free(new_pages, vmalloced);
267                                 return NULL;
268                         }
269                         new_pages[i] = page;
270                 }
271         } else {
272                 for (i = 0; i < want; i++)
273                         new_pages[i] = old_pages[i];
274                 /* NOT HERE, we are outside the spinlock!
275                 bm_free_pages(old_pages + want, have - want);
276                 */
277         }
278
279         if (vmalloced)
280                 set_bit(BM_P_VMALLOCED, &b->bm_flags);
281         else
282                 clear_bit(BM_P_VMALLOCED, &b->bm_flags);
283
284         return new_pages;
285 }
286
287 /*
288  * called on driver init only. TODO call when a device is created.
289  * allocates the drbd_bitmap, and stores it in mdev->bitmap.
290  */
291 int drbd_bm_init(struct drbd_conf *mdev)
292 {
293         struct drbd_bitmap *b = mdev->bitmap;
294         WARN_ON(b != NULL);
295         b = kzalloc(sizeof(struct drbd_bitmap), GFP_KERNEL);
296         if (!b)
297                 return -ENOMEM;
298         spin_lock_init(&b->bm_lock);
299         init_MUTEX(&b->bm_change);
300         init_waitqueue_head(&b->bm_io_wait);
301
302         mdev->bitmap = b;
303
304         return 0;
305 }
306
307 sector_t drbd_bm_capacity(struct drbd_conf *mdev)
308 {
309         ERR_IF(!mdev->bitmap) return 0;
310         return mdev->bitmap->bm_dev_capacity;
311 }
312
313 /* called on driver unload. TODO: call when a device is destroyed.
314  */
315 void drbd_bm_cleanup(struct drbd_conf *mdev)
316 {
317         ERR_IF (!mdev->bitmap) return;
318         bm_free_pages(mdev->bitmap->bm_pages, mdev->bitmap->bm_number_of_pages);
319         bm_vk_free(mdev->bitmap->bm_pages, test_bit(BM_P_VMALLOCED, &mdev->bitmap->bm_flags));
320         kfree(mdev->bitmap);
321         mdev->bitmap = NULL;
322 }
323
324 /*
325  * since (b->bm_bits % BITS_PER_LONG) != 0,
326  * this masks out the remaining bits.
327  * Returns the number of bits cleared.
328  */
329 static int bm_clear_surplus(struct drbd_bitmap *b)
330 {
331         const unsigned long mask = (1UL << (b->bm_bits & (BITS_PER_LONG-1))) - 1;
332         size_t w = b->bm_bits >> LN2_BPL;
333         int cleared = 0;
334         unsigned long *p_addr, *bm;
335
336         p_addr = bm_map_paddr(b, w);
337         bm = p_addr + MLPP(w);
338         if (w < b->bm_words) {
339                 cleared = hweight_long(*bm & ~mask);
340                 *bm &= mask;
341                 w++; bm++;
342         }
343
344         if (w < b->bm_words) {
345                 cleared += hweight_long(*bm);
346                 *bm = 0;
347         }
348         bm_unmap(p_addr);
349         return cleared;
350 }
351
352 static void bm_set_surplus(struct drbd_bitmap *b)
353 {
354         const unsigned long mask = (1UL << (b->bm_bits & (BITS_PER_LONG-1))) - 1;
355         size_t w = b->bm_bits >> LN2_BPL;
356         unsigned long *p_addr, *bm;
357
358         p_addr = bm_map_paddr(b, w);
359         bm = p_addr + MLPP(w);
360         if (w < b->bm_words) {
361                 *bm |= ~mask;
362                 bm++; w++;
363         }
364
365         if (w < b->bm_words) {
366                 *bm = ~(0UL);
367         }
368         bm_unmap(p_addr);
369 }
370
371 static unsigned long __bm_count_bits(struct drbd_bitmap *b, const int swap_endian)
372 {
373         unsigned long *p_addr, *bm, offset = 0;
374         unsigned long bits = 0;
375         unsigned long i, do_now;
376
377         while (offset < b->bm_words) {
378                 i = do_now = min_t(size_t, b->bm_words-offset, LWPP);
379                 p_addr = __bm_map_paddr(b, offset, KM_USER0);
380                 bm = p_addr + MLPP(offset);
381                 while (i--) {
382 #ifndef __LITTLE_ENDIAN
383                         if (swap_endian)
384                                 *bm = lel_to_cpu(*bm);
385 #endif
386                         bits += hweight_long(*bm++);
387                 }
388                 __bm_unmap(p_addr, KM_USER0);
389                 offset += do_now;
390                 cond_resched();
391         }
392
393         return bits;
394 }
395
396 static unsigned long bm_count_bits(struct drbd_bitmap *b)
397 {
398         return __bm_count_bits(b, 0);
399 }
400
401 static unsigned long bm_count_bits_swap_endian(struct drbd_bitmap *b)
402 {
403         return __bm_count_bits(b, 1);
404 }
405
406 /* offset and len in long words.*/
407 static void bm_memset(struct drbd_bitmap *b, size_t offset, int c, size_t len)
408 {
409         unsigned long *p_addr, *bm;
410         size_t do_now, end;
411
412 #define BM_SECTORS_PER_BIT (BM_BLOCK_SIZE/512)
413
414         end = offset + len;
415
416         if (end > b->bm_words) {
417                 printk(KERN_ALERT "drbd: bm_memset end > bm_words\n");
418                 return;
419         }
420
421         while (offset < end) {
422                 do_now = min_t(size_t, ALIGN(offset + 1, LWPP), end) - offset;
423                 p_addr = bm_map_paddr(b, offset);
424                 bm = p_addr + MLPP(offset);
425                 if (bm+do_now > p_addr + LWPP) {
426                         printk(KERN_ALERT "drbd: BUG BUG BUG! p_addr:%p bm:%p do_now:%d\n",
427                                p_addr, bm, (int)do_now);
428                         break; /* breaks to after catch_oob_access_end() only! */
429                 }
430                 memset(bm, c, do_now * sizeof(long));
431                 bm_unmap(p_addr);
432                 offset += do_now;
433         }
434 }
435
436 /*
437  * make sure the bitmap has enough room for the attached storage,
438  * if necessary, resize.
439  * called whenever we may have changed the device size.
440  * returns -ENOMEM if we could not allocate enough memory, 0 on success.
441  * In case this is actually a resize, we copy the old bitmap into the new one.
442  * Otherwise, the bitmap is initialized to all bits set.
443  */
444 int drbd_bm_resize(struct drbd_conf *mdev, sector_t capacity)
445 {
446         struct drbd_bitmap *b = mdev->bitmap;
447         unsigned long bits, words, owords, obits, *p_addr, *bm;
448         unsigned long want, have, onpages; /* number of pages */
449         struct page **npages, **opages = NULL;
450         int err = 0, growing;
451         int opages_vmalloced;
452
453         ERR_IF(!b) return -ENOMEM;
454
455         drbd_bm_lock(mdev, "resize");
456
457         dev_info(DEV, "drbd_bm_resize called with capacity == %llu\n",
458                         (unsigned long long)capacity);
459
460         if (capacity == b->bm_dev_capacity)
461                 goto out;
462
463         opages_vmalloced = test_bit(BM_P_VMALLOCED, &b->bm_flags);
464
465         if (capacity == 0) {
466                 spin_lock_irq(&b->bm_lock);
467                 opages = b->bm_pages;
468                 onpages = b->bm_number_of_pages;
469                 owords = b->bm_words;
470                 b->bm_pages = NULL;
471                 b->bm_number_of_pages =
472                 b->bm_set   =
473                 b->bm_bits  =
474                 b->bm_words =
475                 b->bm_dev_capacity = 0;
476                 spin_unlock_irq(&b->bm_lock);
477                 bm_free_pages(opages, onpages);
478                 bm_vk_free(opages, opages_vmalloced);
479                 goto out;
480         }
481         bits  = BM_SECT_TO_BIT(ALIGN(capacity, BM_SECT_PER_BIT));
482
483         /* if we would use
484            words = ALIGN(bits,BITS_PER_LONG) >> LN2_BPL;
485            a 32bit host could present the wrong number of words
486            to a 64bit host.
487         */
488         words = ALIGN(bits, 64) >> LN2_BPL;
489
490         if (get_ldev(mdev)) {
491                 D_ASSERT((u64)bits <= (((u64)mdev->ldev->md.md_size_sect-MD_BM_OFFSET) << 12));
492                 put_ldev(mdev);
493         }
494
495         /* one extra long to catch off by one errors */
496         want = ALIGN((words+1)*sizeof(long), PAGE_SIZE) >> PAGE_SHIFT;
497         have = b->bm_number_of_pages;
498         if (want == have) {
499                 D_ASSERT(b->bm_pages != NULL);
500                 npages = b->bm_pages;
501         } else {
502                 if (FAULT_ACTIVE(mdev, DRBD_FAULT_BM_ALLOC))
503                         npages = NULL;
504                 else
505                         npages = bm_realloc_pages(b, want);
506         }
507
508         if (!npages) {
509                 err = -ENOMEM;
510                 goto out;
511         }
512
513         spin_lock_irq(&b->bm_lock);
514         opages = b->bm_pages;
515         owords = b->bm_words;
516         obits  = b->bm_bits;
517
518         growing = bits > obits;
519         if (opages)
520                 bm_set_surplus(b);
521
522         b->bm_pages = npages;
523         b->bm_number_of_pages = want;
524         b->bm_bits  = bits;
525         b->bm_words = words;
526         b->bm_dev_capacity = capacity;
527
528         if (growing) {
529                 bm_memset(b, owords, 0xff, words-owords);
530                 b->bm_set += bits - obits;
531         }
532
533         if (want < have) {
534                 /* implicit: (opages != NULL) && (opages != npages) */
535                 bm_free_pages(opages + want, have - want);
536         }
537
538         p_addr = bm_map_paddr(b, words);
539         bm = p_addr + MLPP(words);
540         *bm = DRBD_MAGIC;
541         bm_unmap(p_addr);
542
543         (void)bm_clear_surplus(b);
544
545         spin_unlock_irq(&b->bm_lock);
546         if (opages != npages)
547                 bm_vk_free(opages, opages_vmalloced);
548         if (!growing)
549                 b->bm_set = bm_count_bits(b);
550         dev_info(DEV, "resync bitmap: bits=%lu words=%lu\n", bits, words);
551
552  out:
553         drbd_bm_unlock(mdev);
554         return err;
555 }
556
557 /* inherently racy:
558  * if not protected by other means, return value may be out of date when
559  * leaving this function...
560  * we still need to lock it, since it is important that this returns
561  * bm_set == 0 precisely.
562  *
563  * maybe bm_set should be atomic_t ?
564  */
565 static unsigned long _drbd_bm_total_weight(struct drbd_conf *mdev)
566 {
567         struct drbd_bitmap *b = mdev->bitmap;
568         unsigned long s;
569         unsigned long flags;
570
571         ERR_IF(!b) return 0;
572         ERR_IF(!b->bm_pages) return 0;
573
574         spin_lock_irqsave(&b->bm_lock, flags);
575         s = b->bm_set;
576         spin_unlock_irqrestore(&b->bm_lock, flags);
577
578         return s;
579 }
580
581 unsigned long drbd_bm_total_weight(struct drbd_conf *mdev)
582 {
583         unsigned long s;
584         /* if I don't have a disk, I don't know about out-of-sync status */
585         if (!get_ldev_if_state(mdev, D_NEGOTIATING))
586                 return 0;
587         s = _drbd_bm_total_weight(mdev);
588         put_ldev(mdev);
589         return s;
590 }
591
592 size_t drbd_bm_words(struct drbd_conf *mdev)
593 {
594         struct drbd_bitmap *b = mdev->bitmap;
595         ERR_IF(!b) return 0;
596         ERR_IF(!b->bm_pages) return 0;
597
598         return b->bm_words;
599 }
600
601 unsigned long drbd_bm_bits(struct drbd_conf *mdev)
602 {
603         struct drbd_bitmap *b = mdev->bitmap;
604         ERR_IF(!b) return 0;
605
606         return b->bm_bits;
607 }
608
609 /* merge number words from buffer into the bitmap starting at offset.
610  * buffer[i] is expected to be little endian unsigned long.
611  * bitmap must be locked by drbd_bm_lock.
612  * currently only used from receive_bitmap.
613  */
614 void drbd_bm_merge_lel(struct drbd_conf *mdev, size_t offset, size_t number,
615                         unsigned long *buffer)
616 {
617         struct drbd_bitmap *b = mdev->bitmap;
618         unsigned long *p_addr, *bm;
619         unsigned long word, bits;
620         size_t end, do_now;
621
622         end = offset + number;
623
624         ERR_IF(!b) return;
625         ERR_IF(!b->bm_pages) return;
626         if (number == 0)
627                 return;
628         WARN_ON(offset >= b->bm_words);
629         WARN_ON(end    >  b->bm_words);
630
631         spin_lock_irq(&b->bm_lock);
632         while (offset < end) {
633                 do_now = min_t(size_t, ALIGN(offset+1, LWPP), end) - offset;
634                 p_addr = bm_map_paddr(b, offset);
635                 bm = p_addr + MLPP(offset);
636                 offset += do_now;
637                 while (do_now--) {
638                         bits = hweight_long(*bm);
639                         word = *bm | lel_to_cpu(*buffer++);
640                         *bm++ = word;
641                         b->bm_set += hweight_long(word) - bits;
642                 }
643                 bm_unmap(p_addr);
644         }
645         /* with 32bit <-> 64bit cross-platform connect
646          * this is only correct for current usage,
647          * where we _know_ that we are 64 bit aligned,
648          * and know that this function is used in this way, too...
649          */
650         if (end == b->bm_words)
651                 b->bm_set -= bm_clear_surplus(b);
652
653         spin_unlock_irq(&b->bm_lock);
654 }
655
656 /* copy number words from the bitmap starting at offset into the buffer.
657  * buffer[i] will be little endian unsigned long.
658  */
659 void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset, size_t number,
660                      unsigned long *buffer)
661 {
662         struct drbd_bitmap *b = mdev->bitmap;
663         unsigned long *p_addr, *bm;
664         size_t end, do_now;
665
666         end = offset + number;
667
668         ERR_IF(!b) return;
669         ERR_IF(!b->bm_pages) return;
670
671         spin_lock_irq(&b->bm_lock);
672         if ((offset >= b->bm_words) ||
673             (end    >  b->bm_words) ||
674             (number <= 0))
675                 dev_err(DEV, "offset=%lu number=%lu bm_words=%lu\n",
676                         (unsigned long) offset,
677                         (unsigned long) number,
678                         (unsigned long) b->bm_words);
679         else {
680                 while (offset < end) {
681                         do_now = min_t(size_t, ALIGN(offset+1, LWPP), end) - offset;
682                         p_addr = bm_map_paddr(b, offset);
683                         bm = p_addr + MLPP(offset);
684                         offset += do_now;
685                         while (do_now--)
686                                 *buffer++ = cpu_to_lel(*bm++);
687                         bm_unmap(p_addr);
688                 }
689         }
690         spin_unlock_irq(&b->bm_lock);
691 }
692
693 /* set all bits in the bitmap */
694 void drbd_bm_set_all(struct drbd_conf *mdev)
695 {
696         struct drbd_bitmap *b = mdev->bitmap;
697         ERR_IF(!b) return;
698         ERR_IF(!b->bm_pages) return;
699
700         spin_lock_irq(&b->bm_lock);
701         bm_memset(b, 0, 0xff, b->bm_words);
702         (void)bm_clear_surplus(b);
703         b->bm_set = b->bm_bits;
704         spin_unlock_irq(&b->bm_lock);
705 }
706
707 /* clear all bits in the bitmap */
708 void drbd_bm_clear_all(struct drbd_conf *mdev)
709 {
710         struct drbd_bitmap *b = mdev->bitmap;
711         ERR_IF(!b) return;
712         ERR_IF(!b->bm_pages) return;
713
714         spin_lock_irq(&b->bm_lock);
715         bm_memset(b, 0, 0, b->bm_words);
716         b->bm_set = 0;
717         spin_unlock_irq(&b->bm_lock);
718 }
719
720 static void bm_async_io_complete(struct bio *bio, int error)
721 {
722         struct drbd_bitmap *b = bio->bi_private;
723         int uptodate = bio_flagged(bio, BIO_UPTODATE);
724
725
726         /* strange behavior of some lower level drivers...
727          * fail the request by clearing the uptodate flag,
728          * but do not return any error?!
729          * do we want to WARN() on this? */
730         if (!error && !uptodate)
731                 error = -EIO;
732
733         if (error) {
734                 /* doh. what now?
735                  * for now, set all bits, and flag MD_IO_ERROR */
736                 __set_bit(BM_MD_IO_ERROR, &b->bm_flags);
737         }
738         if (atomic_dec_and_test(&b->bm_async_io))
739                 wake_up(&b->bm_io_wait);
740
741         bio_put(bio);
742 }
743
744 static void bm_page_io_async(struct drbd_conf *mdev, struct drbd_bitmap *b, int page_nr, int rw) __must_hold(local)
745 {
746         /* we are process context. we always get a bio */
747         struct bio *bio = bio_alloc(GFP_KERNEL, 1);
748         unsigned int len;
749         sector_t on_disk_sector =
750                 mdev->ldev->md.md_offset + mdev->ldev->md.bm_offset;
751         on_disk_sector += ((sector_t)page_nr) << (PAGE_SHIFT-9);
752
753         /* this might happen with very small
754          * flexible external meta data device */
755         len = min_t(unsigned int, PAGE_SIZE,
756                 (drbd_md_last_sector(mdev->ldev) - on_disk_sector + 1)<<9);
757
758         bio->bi_bdev = mdev->ldev->md_bdev;
759         bio->bi_sector = on_disk_sector;
760         bio_add_page(bio, b->bm_pages[page_nr], len, 0);
761         bio->bi_private = b;
762         bio->bi_end_io = bm_async_io_complete;
763
764         if (FAULT_ACTIVE(mdev, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD)) {
765                 bio->bi_rw |= rw;
766                 bio_endio(bio, -EIO);
767         } else {
768                 submit_bio(rw, bio);
769         }
770 }
771
772 # if defined(__LITTLE_ENDIAN)
773         /* nothing to do, on disk == in memory */
774 # define bm_cpu_to_lel(x) ((void)0)
775 # else
776 void bm_cpu_to_lel(struct drbd_bitmap *b)
777 {
778         /* need to cpu_to_lel all the pages ...
779          * this may be optimized by using
780          * cpu_to_lel(-1) == -1 and cpu_to_lel(0) == 0;
781          * the following is still not optimal, but better than nothing */
782         unsigned int i;
783         unsigned long *p_addr, *bm;
784         if (b->bm_set == 0) {
785                 /* no page at all; avoid swap if all is 0 */
786                 i = b->bm_number_of_pages;
787         } else if (b->bm_set == b->bm_bits) {
788                 /* only the last page */
789                 i = b->bm_number_of_pages - 1;
790         } else {
791                 /* all pages */
792                 i = 0;
793         }
794         for (; i < b->bm_number_of_pages; i++) {
795                 p_addr = kmap_atomic(b->bm_pages[i], KM_USER0);
796                 for (bm = p_addr; bm < p_addr + PAGE_SIZE/sizeof(long); bm++)
797                         *bm = cpu_to_lel(*bm);
798                 kunmap_atomic(p_addr, KM_USER0);
799         }
800 }
801 # endif
802 /* lel_to_cpu == cpu_to_lel */
803 # define bm_lel_to_cpu(x) bm_cpu_to_lel(x)
804
805 /*
806  * bm_rw: read/write the whole bitmap from/to its on disk location.
807  */
808 static int bm_rw(struct drbd_conf *mdev, int rw) __must_hold(local)
809 {
810         struct drbd_bitmap *b = mdev->bitmap;
811         /* sector_t sector; */
812         int bm_words, num_pages, i;
813         unsigned long now;
814         char ppb[10];
815         int err = 0;
816
817         WARN_ON(!bm_is_locked(b));
818
819         /* no spinlock here, the drbd_bm_lock should be enough! */
820
821         bm_words  = drbd_bm_words(mdev);
822         num_pages = (bm_words*sizeof(long) + PAGE_SIZE-1) >> PAGE_SHIFT;
823
824         /* on disk bitmap is little endian */
825         if (rw == WRITE)
826                 bm_cpu_to_lel(b);
827
828         now = jiffies;
829         atomic_set(&b->bm_async_io, num_pages);
830         __clear_bit(BM_MD_IO_ERROR, &b->bm_flags);
831
832         /* let the layers below us try to merge these bios... */
833         for (i = 0; i < num_pages; i++)
834                 bm_page_io_async(mdev, b, i, rw);
835
836         drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
837         wait_event(b->bm_io_wait, atomic_read(&b->bm_async_io) == 0);
838
839         if (test_bit(BM_MD_IO_ERROR, &b->bm_flags)) {
840                 dev_alert(DEV, "we had at least one MD IO ERROR during bitmap IO\n");
841                 drbd_chk_io_error(mdev, 1, TRUE);
842                 err = -EIO;
843         }
844
845         now = jiffies;
846         if (rw == WRITE) {
847                 /* swap back endianness */
848                 bm_lel_to_cpu(b);
849                 /* flush bitmap to stable storage */
850                 drbd_md_flush(mdev);
851         } else /* rw == READ */ {
852                 /* just read, if necessary adjust endianness */
853                 b->bm_set = bm_count_bits_swap_endian(b);
854                 dev_info(DEV, "recounting of set bits took additional %lu jiffies\n",
855                      jiffies - now);
856         }
857         now = b->bm_set;
858
859         dev_info(DEV, "%s (%lu bits) marked out-of-sync by on disk bit-map.\n",
860              ppsize(ppb, now << (BM_BLOCK_SHIFT-10)), now);
861
862         return err;
863 }
864
865 /**
866  * drbd_bm_read() - Read the whole bitmap from its on disk location.
867  * @mdev:       DRBD device.
868  */
869 int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local)
870 {
871         return bm_rw(mdev, READ);
872 }
873
874 /**
875  * drbd_bm_write() - Write the whole bitmap to its on disk location.
876  * @mdev:       DRBD device.
877  */
878 int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local)
879 {
880         return bm_rw(mdev, WRITE);
881 }
882
883 /**
884  * drbd_bm_write_sect: Writes a 512 (MD_SECTOR_SIZE) byte piece of the bitmap
885  * @mdev:       DRBD device.
886  * @enr:        Extent number in the resync lru (happens to be sector offset)
887  *
888  * The BM_EXT_SIZE is on purpose exactly the amount of the bitmap covered
889  * by a single sector write. Therefore enr == sector offset from the
890  * start of the bitmap.
891  */
892 int drbd_bm_write_sect(struct drbd_conf *mdev, unsigned long enr) __must_hold(local)
893 {
894         sector_t on_disk_sector = enr + mdev->ldev->md.md_offset
895                                       + mdev->ldev->md.bm_offset;
896         int bm_words, num_words, offset;
897         int err = 0;
898
899         mutex_lock(&mdev->md_io_mutex);
900         bm_words  = drbd_bm_words(mdev);
901         offset    = S2W(enr);   /* word offset into bitmap */
902         num_words = min(S2W(1), bm_words - offset);
903         if (num_words < S2W(1))
904                 memset(page_address(mdev->md_io_page), 0, MD_SECTOR_SIZE);
905         drbd_bm_get_lel(mdev, offset, num_words,
906                         page_address(mdev->md_io_page));
907         if (!drbd_md_sync_page_io(mdev, mdev->ldev, on_disk_sector, WRITE)) {
908                 int i;
909                 err = -EIO;
910                 dev_err(DEV, "IO ERROR writing bitmap sector %lu "
911                     "(meta-disk sector %llus)\n",
912                     enr, (unsigned long long)on_disk_sector);
913                 drbd_chk_io_error(mdev, 1, TRUE);
914                 for (i = 0; i < AL_EXT_PER_BM_SECT; i++)
915                         drbd_bm_ALe_set_all(mdev, enr*AL_EXT_PER_BM_SECT+i);
916         }
917         mdev->bm_writ_cnt++;
918         mutex_unlock(&mdev->md_io_mutex);
919         return err;
920 }
921
922 /* NOTE
923  * find_first_bit returns int, we return unsigned long.
924  * should not make much difference anyways, but ...
925  *
926  * this returns a bit number, NOT a sector!
927  */
928 #define BPP_MASK ((1UL << (PAGE_SHIFT+3)) - 1)
929 static unsigned long __bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo,
930         const int find_zero_bit, const enum km_type km)
931 {
932         struct drbd_bitmap *b = mdev->bitmap;
933         unsigned long i = -1UL;
934         unsigned long *p_addr;
935         unsigned long bit_offset; /* bit offset of the mapped page. */
936
937         if (bm_fo > b->bm_bits) {
938                 dev_err(DEV, "bm_fo=%lu bm_bits=%lu\n", bm_fo, b->bm_bits);
939         } else {
940                 while (bm_fo < b->bm_bits) {
941                         unsigned long offset;
942                         bit_offset = bm_fo & ~BPP_MASK; /* bit offset of the page */
943                         offset = bit_offset >> LN2_BPL;    /* word offset of the page */
944                         p_addr = __bm_map_paddr(b, offset, km);
945
946                         if (find_zero_bit)
947                                 i = find_next_zero_bit(p_addr, PAGE_SIZE*8, bm_fo & BPP_MASK);
948                         else
949                                 i = find_next_bit(p_addr, PAGE_SIZE*8, bm_fo & BPP_MASK);
950
951                         __bm_unmap(p_addr, km);
952                         if (i < PAGE_SIZE*8) {
953                                 i = bit_offset + i;
954                                 if (i >= b->bm_bits)
955                                         break;
956                                 goto found;
957                         }
958                         bm_fo = bit_offset + PAGE_SIZE*8;
959                 }
960                 i = -1UL;
961         }
962  found:
963         return i;
964 }
965
966 static unsigned long bm_find_next(struct drbd_conf *mdev,
967         unsigned long bm_fo, const int find_zero_bit)
968 {
969         struct drbd_bitmap *b = mdev->bitmap;
970         unsigned long i = -1UL;
971
972         ERR_IF(!b) return i;
973         ERR_IF(!b->bm_pages) return i;
974
975         spin_lock_irq(&b->bm_lock);
976         if (bm_is_locked(b))
977                 bm_print_lock_info(mdev);
978
979         i = __bm_find_next(mdev, bm_fo, find_zero_bit, KM_IRQ1);
980
981         spin_unlock_irq(&b->bm_lock);
982         return i;
983 }
984
985 unsigned long drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo)
986 {
987         return bm_find_next(mdev, bm_fo, 0);
988 }
989
990 #if 0
991 /* not yet needed for anything. */
992 unsigned long drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo)
993 {
994         return bm_find_next(mdev, bm_fo, 1);
995 }
996 #endif
997
998 /* does not spin_lock_irqsave.
999  * you must take drbd_bm_lock() first */
1000 unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo)
1001 {
1002         /* WARN_ON(!bm_is_locked(mdev)); */
1003         return __bm_find_next(mdev, bm_fo, 0, KM_USER1);
1004 }
1005
1006 unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo)
1007 {
1008         /* WARN_ON(!bm_is_locked(mdev)); */
1009         return __bm_find_next(mdev, bm_fo, 1, KM_USER1);
1010 }
1011
1012 /* returns number of bits actually changed.
1013  * for val != 0, we change 0 -> 1, return code positive
1014  * for val == 0, we change 1 -> 0, return code negative
1015  * wants bitnr, not sector.
1016  * expected to be called for only a few bits (e - s about BITS_PER_LONG).
1017  * Must hold bitmap lock already. */
1018 int __bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
1019         unsigned long e, int val, const enum km_type km)
1020 {
1021         struct drbd_bitmap *b = mdev->bitmap;
1022         unsigned long *p_addr = NULL;
1023         unsigned long bitnr;
1024         unsigned long last_page_nr = -1UL;
1025         int c = 0;
1026
1027         if (e >= b->bm_bits) {
1028                 dev_err(DEV, "ASSERT FAILED: bit_s=%lu bit_e=%lu bm_bits=%lu\n",
1029                                 s, e, b->bm_bits);
1030                 e = b->bm_bits ? b->bm_bits -1 : 0;
1031         }
1032         for (bitnr = s; bitnr <= e; bitnr++) {
1033                 unsigned long offset = bitnr>>LN2_BPL;
1034                 unsigned long page_nr = offset >> (PAGE_SHIFT - LN2_BPL + 3);
1035                 if (page_nr != last_page_nr) {
1036                         if (p_addr)
1037                                 __bm_unmap(p_addr, km);
1038                         p_addr = __bm_map_paddr(b, offset, km);
1039                         last_page_nr = page_nr;
1040                 }
1041                 if (val)
1042                         c += (0 == __test_and_set_bit(bitnr & BPP_MASK, p_addr));
1043                 else
1044                         c -= (0 != __test_and_clear_bit(bitnr & BPP_MASK, p_addr));
1045         }
1046         if (p_addr)
1047                 __bm_unmap(p_addr, km);
1048         b->bm_set += c;
1049         return c;
1050 }
1051
1052 /* returns number of bits actually changed.
1053  * for val != 0, we change 0 -> 1, return code positive
1054  * for val == 0, we change 1 -> 0, return code negative
1055  * wants bitnr, not sector */
1056 int bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
1057         const unsigned long e, int val)
1058 {
1059         unsigned long flags;
1060         struct drbd_bitmap *b = mdev->bitmap;
1061         int c = 0;
1062
1063         ERR_IF(!b) return 1;
1064         ERR_IF(!b->bm_pages) return 0;
1065
1066         spin_lock_irqsave(&b->bm_lock, flags);
1067         if (bm_is_locked(b))
1068                 bm_print_lock_info(mdev);
1069
1070         c = __bm_change_bits_to(mdev, s, e, val, KM_IRQ1);
1071
1072         spin_unlock_irqrestore(&b->bm_lock, flags);
1073         return c;
1074 }
1075
1076 /* returns number of bits changed 0 -> 1 */
1077 int drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
1078 {
1079         return bm_change_bits_to(mdev, s, e, 1);
1080 }
1081
1082 /* returns number of bits changed 1 -> 0 */
1083 int drbd_bm_clear_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
1084 {
1085         return -bm_change_bits_to(mdev, s, e, 0);
1086 }
1087
1088 /* sets all bits in full words,
1089  * from first_word up to, but not including, last_word */
1090 static inline void bm_set_full_words_within_one_page(struct drbd_bitmap *b,
1091                 int page_nr, int first_word, int last_word)
1092 {
1093         int i;
1094         int bits;
1095         unsigned long *paddr = kmap_atomic(b->bm_pages[page_nr], KM_USER0);
1096         for (i = first_word; i < last_word; i++) {
1097                 bits = hweight_long(paddr[i]);
1098                 paddr[i] = ~0UL;
1099                 b->bm_set += BITS_PER_LONG - bits;
1100         }
1101         kunmap_atomic(paddr, KM_USER0);
1102 }
1103
1104 /* Same thing as drbd_bm_set_bits, but without taking the spin_lock_irqsave.
1105  * You must first drbd_bm_lock().
1106  * Can be called to set the whole bitmap in one go.
1107  * Sets bits from s to e _inclusive_. */
1108 void _drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
1109 {
1110         /* First set_bit from the first bit (s)
1111          * up to the next long boundary (sl),
1112          * then assign full words up to the last long boundary (el),
1113          * then set_bit up to and including the last bit (e).
1114          *
1115          * Do not use memset, because we must account for changes,
1116          * so we need to loop over the words with hweight() anyways.
1117          */
1118         unsigned long sl = ALIGN(s,BITS_PER_LONG);
1119         unsigned long el = (e+1) & ~((unsigned long)BITS_PER_LONG-1);
1120         int first_page;
1121         int last_page;
1122         int page_nr;
1123         int first_word;
1124         int last_word;
1125
1126         if (e - s <= 3*BITS_PER_LONG) {
1127                 /* don't bother; el and sl may even be wrong. */
1128                 __bm_change_bits_to(mdev, s, e, 1, KM_USER0);
1129                 return;
1130         }
1131
1132         /* difference is large enough that we can trust sl and el */
1133
1134         /* bits filling the current long */
1135         if (sl)
1136                 __bm_change_bits_to(mdev, s, sl-1, 1, KM_USER0);
1137
1138         first_page = sl >> (3 + PAGE_SHIFT);
1139         last_page = el >> (3 + PAGE_SHIFT);
1140
1141         /* MLPP: modulo longs per page */
1142         /* LWPP: long words per page */
1143         first_word = MLPP(sl >> LN2_BPL);
1144         last_word = LWPP;
1145
1146         /* first and full pages, unless first page == last page */
1147         for (page_nr = first_page; page_nr < last_page; page_nr++) {
1148                 bm_set_full_words_within_one_page(mdev->bitmap, page_nr, first_word, last_word);
1149                 cond_resched();
1150                 first_word = 0;
1151         }
1152
1153         /* last page (respectively only page, for first page == last page) */
1154         last_word = MLPP(el >> LN2_BPL);
1155         bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
1156
1157         /* possibly trailing bits.
1158          * example: (e & 63) == 63, el will be e+1.
1159          * if that even was the very last bit,
1160          * it would trigger an assert in __bm_change_bits_to()
1161          */
1162         if (el <= e)
1163                 __bm_change_bits_to(mdev, el, e, 1, KM_USER0);
1164 }
1165
1166 /* returns bit state
1167  * wants bitnr, NOT sector.
1168  * inherently racy... area needs to be locked by means of {al,rs}_lru
1169  *  1 ... bit set
1170  *  0 ... bit not set
1171  * -1 ... first out of bounds access, stop testing for bits!
1172  */
1173 int drbd_bm_test_bit(struct drbd_conf *mdev, const unsigned long bitnr)
1174 {
1175         unsigned long flags;
1176         struct drbd_bitmap *b = mdev->bitmap;
1177         unsigned long *p_addr;
1178         int i;
1179
1180         ERR_IF(!b) return 0;
1181         ERR_IF(!b->bm_pages) return 0;
1182
1183         spin_lock_irqsave(&b->bm_lock, flags);
1184         if (bm_is_locked(b))
1185                 bm_print_lock_info(mdev);
1186         if (bitnr < b->bm_bits) {
1187                 unsigned long offset = bitnr>>LN2_BPL;
1188                 p_addr = bm_map_paddr(b, offset);
1189                 i = test_bit(bitnr & BPP_MASK, p_addr) ? 1 : 0;
1190                 bm_unmap(p_addr);
1191         } else if (bitnr == b->bm_bits) {
1192                 i = -1;
1193         } else { /* (bitnr > b->bm_bits) */
1194                 dev_err(DEV, "bitnr=%lu > bm_bits=%lu\n", bitnr, b->bm_bits);
1195                 i = 0;
1196         }
1197
1198         spin_unlock_irqrestore(&b->bm_lock, flags);
1199         return i;
1200 }
1201
1202 /* returns number of bits set in the range [s, e] */
1203 int drbd_bm_count_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
1204 {
1205         unsigned long flags;
1206         struct drbd_bitmap *b = mdev->bitmap;
1207         unsigned long *p_addr = NULL, page_nr = -1;
1208         unsigned long bitnr;
1209         int c = 0;
1210         size_t w;
1211
1212         /* If this is called without a bitmap, that is a bug.  But just to be
1213          * robust in case we screwed up elsewhere, in that case pretend there
1214          * was one dirty bit in the requested area, so we won't try to do a
1215          * local read there (no bitmap probably implies no disk) */
1216         ERR_IF(!b) return 1;
1217         ERR_IF(!b->bm_pages) return 1;
1218
1219         spin_lock_irqsave(&b->bm_lock, flags);
1220         if (bm_is_locked(b))
1221                 bm_print_lock_info(mdev);
1222         for (bitnr = s; bitnr <= e; bitnr++) {
1223                 w = bitnr >> LN2_BPL;
1224                 if (page_nr != w >> (PAGE_SHIFT - LN2_BPL + 3)) {
1225                         page_nr = w >> (PAGE_SHIFT - LN2_BPL + 3);
1226                         if (p_addr)
1227                                 bm_unmap(p_addr);
1228                         p_addr = bm_map_paddr(b, w);
1229                 }
1230                 ERR_IF (bitnr >= b->bm_bits) {
1231                         dev_err(DEV, "bitnr=%lu bm_bits=%lu\n", bitnr, b->bm_bits);
1232                 } else {
1233                         c += (0 != test_bit(bitnr - (page_nr << (PAGE_SHIFT+3)), p_addr));
1234                 }
1235         }
1236         if (p_addr)
1237                 bm_unmap(p_addr);
1238         spin_unlock_irqrestore(&b->bm_lock, flags);
1239         return c;
1240 }
1241
1242
1243 /* inherently racy...
1244  * return value may be already out-of-date when this function returns.
1245  * but the general usage is that this is only use during a cstate when bits are
1246  * only cleared, not set, and typically only care for the case when the return
1247  * value is zero, or we already "locked" this "bitmap extent" by other means.
1248  *
1249  * enr is bm-extent number, since we chose to name one sector (512 bytes)
1250  * worth of the bitmap a "bitmap extent".
1251  *
1252  * TODO
1253  * I think since we use it like a reference count, we should use the real
1254  * reference count of some bitmap extent element from some lru instead...
1255  *
1256  */
1257 int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr)
1258 {
1259         struct drbd_bitmap *b = mdev->bitmap;
1260         int count, s, e;
1261         unsigned long flags;
1262         unsigned long *p_addr, *bm;
1263
1264         ERR_IF(!b) return 0;
1265         ERR_IF(!b->bm_pages) return 0;
1266
1267         spin_lock_irqsave(&b->bm_lock, flags);
1268         if (bm_is_locked(b))
1269                 bm_print_lock_info(mdev);
1270
1271         s = S2W(enr);
1272         e = min((size_t)S2W(enr+1), b->bm_words);
1273         count = 0;
1274         if (s < b->bm_words) {
1275                 int n = e-s;
1276                 p_addr = bm_map_paddr(b, s);
1277                 bm = p_addr + MLPP(s);
1278                 while (n--)
1279                         count += hweight_long(*bm++);
1280                 bm_unmap(p_addr);
1281         } else {
1282                 dev_err(DEV, "start offset (%d) too large in drbd_bm_e_weight\n", s);
1283         }
1284         spin_unlock_irqrestore(&b->bm_lock, flags);
1285         return count;
1286 }
1287
1288 /* set all bits covered by the AL-extent al_enr */
1289 unsigned long drbd_bm_ALe_set_all(struct drbd_conf *mdev, unsigned long al_enr)
1290 {
1291         struct drbd_bitmap *b = mdev->bitmap;
1292         unsigned long *p_addr, *bm;
1293         unsigned long weight;
1294         int count, s, e, i, do_now;
1295         ERR_IF(!b) return 0;
1296         ERR_IF(!b->bm_pages) return 0;
1297
1298         spin_lock_irq(&b->bm_lock);
1299         if (bm_is_locked(b))
1300                 bm_print_lock_info(mdev);
1301         weight = b->bm_set;
1302
1303         s = al_enr * BM_WORDS_PER_AL_EXT;
1304         e = min_t(size_t, s + BM_WORDS_PER_AL_EXT, b->bm_words);
1305         /* assert that s and e are on the same page */
1306         D_ASSERT((e-1) >> (PAGE_SHIFT - LN2_BPL + 3)
1307               ==  s    >> (PAGE_SHIFT - LN2_BPL + 3));
1308         count = 0;
1309         if (s < b->bm_words) {
1310                 i = do_now = e-s;
1311                 p_addr = bm_map_paddr(b, s);
1312                 bm = p_addr + MLPP(s);
1313                 while (i--) {
1314                         count += hweight_long(*bm);
1315                         *bm = -1UL;
1316                         bm++;
1317                 }
1318                 bm_unmap(p_addr);
1319                 b->bm_set += do_now*BITS_PER_LONG - count;
1320                 if (e == b->bm_words)
1321                         b->bm_set -= bm_clear_surplus(b);
1322         } else {
1323                 dev_err(DEV, "start offset (%d) too large in drbd_bm_ALe_set_all\n", s);
1324         }
1325         weight = b->bm_set - weight;
1326         spin_unlock_irq(&b->bm_lock);
1327         return weight;
1328 }