mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Fabio M. De Francesco](/assets/img/avatar_default.png)
kmap() is being deprecated in favor of kmap_local_page(). There are two main problems with kmap(): (1) It comes with an overhead as mapping space is restricted and protected by a global lock for synchronization and (2) it also requires global TLB invalidation when the kmap's pool wraps and it might block when the mapping space is fully utilized until a slot becomes available. With kmap_local_page() the mappings are per thread, CPU local, can take page faults, and can be called from any context (including interrupts). It is faster than kmap() in kernels with HIGHMEM enabled. Furthermore, the tasks can be preempted and, when they are scheduled to run again, the kernel virtual addresses are restored and are still valid. Since its use in bitmap.c is safe everywhere, it should be preferred. Therefore, replace kmap() with kmap_local_page() in bitmap.c. Tested in a QEMU/KVM x86_32 VM, 6GB RAM, booting a kernel with HIGHMEM64GB enabled. Link: https://lkml.kernel.org/r/20220809203105.26183-4-fmdefrancesco@gmail.com Signed-off-by: Fabio M. De Francesco <fmdefrancesco@gmail.com> Suggested-by: Ira Weiny <ira.weiny@intel.com> Reviewed-by: Ira Weiny <ira.weiny@intel.com> Reviewed-by: Viacheslav Dubeyko <slava@dubeyko.com> Cc: Bart Van Assche <bvanassche@acm.org> Cc: Jens Axboe <axboe@kernel.dk> Cc: Kees Cook <keescook@chromium.org> Cc: Matthew Wilcox <willy@infradead.org> Cc: Muchun Song <songmuchun@bytedance.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
246 lines
5.1 KiB
C
246 lines
5.1 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* linux/fs/hfsplus/bitmap.c
|
|
*
|
|
* Copyright (C) 2001
|
|
* Brad Boyer (flar@allandria.com)
|
|
* (C) 2003 Ardis Technologies <roman@ardistech.com>
|
|
*
|
|
* Handling of allocation file
|
|
*/
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include "hfsplus_fs.h"
|
|
#include "hfsplus_raw.h"
|
|
|
|
#define PAGE_CACHE_BITS (PAGE_SIZE * 8)
|
|
|
|
int hfsplus_block_allocate(struct super_block *sb, u32 size,
|
|
u32 offset, u32 *max)
|
|
{
|
|
struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
|
|
struct page *page;
|
|
struct address_space *mapping;
|
|
__be32 *pptr, *curr, *end;
|
|
u32 mask, start, len, n;
|
|
__be32 val;
|
|
int i;
|
|
|
|
len = *max;
|
|
if (!len)
|
|
return size;
|
|
|
|
hfs_dbg(BITMAP, "block_allocate: %u,%u,%u\n", size, offset, len);
|
|
mutex_lock(&sbi->alloc_mutex);
|
|
mapping = sbi->alloc_file->i_mapping;
|
|
page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS, NULL);
|
|
if (IS_ERR(page)) {
|
|
start = size;
|
|
goto out;
|
|
}
|
|
pptr = kmap_local_page(page);
|
|
curr = pptr + (offset & (PAGE_CACHE_BITS - 1)) / 32;
|
|
i = offset % 32;
|
|
offset &= ~(PAGE_CACHE_BITS - 1);
|
|
if ((size ^ offset) / PAGE_CACHE_BITS)
|
|
end = pptr + PAGE_CACHE_BITS / 32;
|
|
else
|
|
end = pptr + ((size + 31) & (PAGE_CACHE_BITS - 1)) / 32;
|
|
|
|
/* scan the first partial u32 for zero bits */
|
|
val = *curr;
|
|
if (~val) {
|
|
n = be32_to_cpu(val);
|
|
mask = (1U << 31) >> i;
|
|
for (; i < 32; mask >>= 1, i++) {
|
|
if (!(n & mask))
|
|
goto found;
|
|
}
|
|
}
|
|
curr++;
|
|
|
|
/* scan complete u32s for the first zero bit */
|
|
while (1) {
|
|
while (curr < end) {
|
|
val = *curr;
|
|
if (~val) {
|
|
n = be32_to_cpu(val);
|
|
mask = 1 << 31;
|
|
for (i = 0; i < 32; mask >>= 1, i++) {
|
|
if (!(n & mask))
|
|
goto found;
|
|
}
|
|
}
|
|
curr++;
|
|
}
|
|
kunmap_local(pptr);
|
|
offset += PAGE_CACHE_BITS;
|
|
if (offset >= size)
|
|
break;
|
|
page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS,
|
|
NULL);
|
|
if (IS_ERR(page)) {
|
|
start = size;
|
|
goto out;
|
|
}
|
|
curr = pptr = kmap_local_page(page);
|
|
if ((size ^ offset) / PAGE_CACHE_BITS)
|
|
end = pptr + PAGE_CACHE_BITS / 32;
|
|
else
|
|
end = pptr + ((size + 31) & (PAGE_CACHE_BITS - 1)) / 32;
|
|
}
|
|
hfs_dbg(BITMAP, "bitmap full\n");
|
|
start = size;
|
|
goto out;
|
|
|
|
found:
|
|
start = offset + (curr - pptr) * 32 + i;
|
|
if (start >= size) {
|
|
hfs_dbg(BITMAP, "bitmap full\n");
|
|
goto out;
|
|
}
|
|
/* do any partial u32 at the start */
|
|
len = min(size - start, len);
|
|
while (1) {
|
|
n |= mask;
|
|
if (++i >= 32)
|
|
break;
|
|
mask >>= 1;
|
|
if (!--len || n & mask)
|
|
goto done;
|
|
}
|
|
if (!--len)
|
|
goto done;
|
|
*curr++ = cpu_to_be32(n);
|
|
/* do full u32s */
|
|
while (1) {
|
|
while (curr < end) {
|
|
n = be32_to_cpu(*curr);
|
|
if (len < 32)
|
|
goto last;
|
|
if (n) {
|
|
len = 32;
|
|
goto last;
|
|
}
|
|
*curr++ = cpu_to_be32(0xffffffff);
|
|
len -= 32;
|
|
}
|
|
set_page_dirty(page);
|
|
kunmap_local(pptr);
|
|
offset += PAGE_CACHE_BITS;
|
|
page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS,
|
|
NULL);
|
|
if (IS_ERR(page)) {
|
|
start = size;
|
|
goto out;
|
|
}
|
|
pptr = kmap_local_page(page);
|
|
curr = pptr;
|
|
end = pptr + PAGE_CACHE_BITS / 32;
|
|
}
|
|
last:
|
|
/* do any partial u32 at end */
|
|
mask = 1U << 31;
|
|
for (i = 0; i < len; i++) {
|
|
if (n & mask)
|
|
break;
|
|
n |= mask;
|
|
mask >>= 1;
|
|
}
|
|
done:
|
|
*curr = cpu_to_be32(n);
|
|
set_page_dirty(page);
|
|
kunmap_local(pptr);
|
|
*max = offset + (curr - pptr) * 32 + i - start;
|
|
sbi->free_blocks -= *max;
|
|
hfsplus_mark_mdb_dirty(sb);
|
|
hfs_dbg(BITMAP, "-> %u,%u\n", start, *max);
|
|
out:
|
|
mutex_unlock(&sbi->alloc_mutex);
|
|
return start;
|
|
}
|
|
|
|
int hfsplus_block_free(struct super_block *sb, u32 offset, u32 count)
|
|
{
|
|
struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
|
|
struct page *page;
|
|
struct address_space *mapping;
|
|
__be32 *pptr, *curr, *end;
|
|
u32 mask, len, pnr;
|
|
int i;
|
|
|
|
/* is there any actual work to be done? */
|
|
if (!count)
|
|
return 0;
|
|
|
|
hfs_dbg(BITMAP, "block_free: %u,%u\n", offset, count);
|
|
/* are all of the bits in range? */
|
|
if ((offset + count) > sbi->total_blocks)
|
|
return -ENOENT;
|
|
|
|
mutex_lock(&sbi->alloc_mutex);
|
|
mapping = sbi->alloc_file->i_mapping;
|
|
pnr = offset / PAGE_CACHE_BITS;
|
|
page = read_mapping_page(mapping, pnr, NULL);
|
|
if (IS_ERR(page))
|
|
goto kaboom;
|
|
pptr = kmap_local_page(page);
|
|
curr = pptr + (offset & (PAGE_CACHE_BITS - 1)) / 32;
|
|
end = pptr + PAGE_CACHE_BITS / 32;
|
|
len = count;
|
|
|
|
/* do any partial u32 at the start */
|
|
i = offset % 32;
|
|
if (i) {
|
|
int j = 32 - i;
|
|
mask = 0xffffffffU << j;
|
|
if (j > count) {
|
|
mask |= 0xffffffffU >> (i + count);
|
|
*curr++ &= cpu_to_be32(mask);
|
|
goto out;
|
|
}
|
|
*curr++ &= cpu_to_be32(mask);
|
|
count -= j;
|
|
}
|
|
|
|
/* do full u32s */
|
|
while (1) {
|
|
while (curr < end) {
|
|
if (count < 32)
|
|
goto done;
|
|
*curr++ = 0;
|
|
count -= 32;
|
|
}
|
|
if (!count)
|
|
break;
|
|
set_page_dirty(page);
|
|
kunmap_local(pptr);
|
|
page = read_mapping_page(mapping, ++pnr, NULL);
|
|
if (IS_ERR(page))
|
|
goto kaboom;
|
|
pptr = kmap_local_page(page);
|
|
curr = pptr;
|
|
end = pptr + PAGE_CACHE_BITS / 32;
|
|
}
|
|
done:
|
|
/* do any partial u32 at end */
|
|
if (count) {
|
|
mask = 0xffffffffU >> count;
|
|
*curr &= cpu_to_be32(mask);
|
|
}
|
|
out:
|
|
set_page_dirty(page);
|
|
kunmap_local(pptr);
|
|
sbi->free_blocks += len;
|
|
hfsplus_mark_mdb_dirty(sb);
|
|
mutex_unlock(&sbi->alloc_mutex);
|
|
|
|
return 0;
|
|
|
|
kaboom:
|
|
pr_crit("unable to mark blocks free: error %ld\n", PTR_ERR(page));
|
|
mutex_unlock(&sbi->alloc_mutex);
|
|
|
|
return -EIO;
|
|
}
|