Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
nilfs2: convert DAT file to be folio-based
Regarding the DAT, a metadata file that manages virtual block addresses,
convert the page-based implementation to a folio-based implementation.
Link: https://lkml.kernel.org/r/20241024092602.13395-7-konishi.ryusuke@gmail.com
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
authored by
Ryusuke Konishi
and committed by
Andrew Morton
aac6925e
f99de3d5
+52
-46
+52
-46
fs/nilfs2/dat.c
+52
-46
fs/nilfs2/dat.c
···
89
89
void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
90
90
{
91
91
struct nilfs_dat_entry *entry;
92
-
void *kaddr;
92
+
size_t offset;
93
93
94
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
95
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
96
-
req->pr_entry_bh, kaddr);
94
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
95
+
req->pr_entry_bh);
96
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
97
97
entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
98
98
entry->de_end = cpu_to_le64(NILFS_CNO_MAX);
99
99
entry->de_blocknr = cpu_to_le64(0);
100
-
kunmap_local(kaddr);
100
+
kunmap_local(entry);
101
101
102
102
nilfs_palloc_commit_alloc_entry(dat, req);
103
103
nilfs_dat_commit_entry(dat, req);
···
113
113
struct nilfs_palloc_req *req)
114
114
{
115
115
struct nilfs_dat_entry *entry;
116
-
void *kaddr;
116
+
size_t offset;
117
117
118
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
119
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
120
-
req->pr_entry_bh, kaddr);
118
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
119
+
req->pr_entry_bh);
120
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
121
121
entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
122
122
entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
123
123
entry->de_blocknr = cpu_to_le64(0);
124
-
kunmap_local(kaddr);
124
+
kunmap_local(entry);
125
125
126
126
nilfs_dat_commit_entry(dat, req);
127
127
···
143
143
sector_t blocknr)
144
144
{
145
145
struct nilfs_dat_entry *entry;
146
-
void *kaddr;
146
+
size_t offset;
147
147
148
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
149
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
150
-
req->pr_entry_bh, kaddr);
148
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
149
+
req->pr_entry_bh);
150
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
151
151
entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
152
152
entry->de_blocknr = cpu_to_le64(blocknr);
153
-
kunmap_local(kaddr);
153
+
kunmap_local(entry);
154
154
155
155
nilfs_dat_commit_entry(dat, req);
156
156
}
···
160
160
struct nilfs_dat_entry *entry;
161
161
__u64 start;
162
162
sector_t blocknr;
163
-
void *kaddr;
163
+
size_t offset;
164
164
int ret;
165
165
166
166
ret = nilfs_dat_prepare_entry(dat, req, 0);
167
167
if (ret < 0)
168
168
return ret;
169
169
170
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
171
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
172
-
req->pr_entry_bh, kaddr);
170
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
171
+
req->pr_entry_bh);
172
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
173
173
start = le64_to_cpu(entry->de_start);
174
174
blocknr = le64_to_cpu(entry->de_blocknr);
175
-
kunmap_local(kaddr);
175
+
kunmap_local(entry);
176
176
177
177
if (blocknr == 0) {
178
178
ret = nilfs_palloc_prepare_free_entry(dat, req);
···
200
200
struct nilfs_dat_entry *entry;
201
201
__u64 start, end;
202
202
sector_t blocknr;
203
-
void *kaddr;
203
+
size_t offset;
204
204
205
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
206
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
207
-
req->pr_entry_bh, kaddr);
205
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
206
+
req->pr_entry_bh);
207
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
208
208
end = start = le64_to_cpu(entry->de_start);
209
209
if (!dead) {
210
210
end = nilfs_mdt_cno(dat);
···
212
212
}
213
213
entry->de_end = cpu_to_le64(end);
214
214
blocknr = le64_to_cpu(entry->de_blocknr);
215
-
kunmap_local(kaddr);
215
+
kunmap_local(entry);
216
216
217
217
if (blocknr == 0)
218
218
nilfs_dat_commit_free(dat, req);
···
225
225
struct nilfs_dat_entry *entry;
226
226
__u64 start;
227
227
sector_t blocknr;
228
-
void *kaddr;
228
+
size_t offset;
229
229
230
-
kaddr = kmap_local_page(req->pr_entry_bh->b_page);
231
-
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
232
-
req->pr_entry_bh, kaddr);
230
+
offset = nilfs_palloc_entry_offset(dat, req->pr_entry_nr,
231
+
req->pr_entry_bh);
232
+
entry = kmap_local_folio(req->pr_entry_bh->b_folio, offset);
233
233
start = le64_to_cpu(entry->de_start);
234
234
blocknr = le64_to_cpu(entry->de_blocknr);
235
-
kunmap_local(kaddr);
235
+
kunmap_local(entry);
236
236
237
237
if (start == nilfs_mdt_cno(dat) && blocknr == 0)
238
238
nilfs_palloc_abort_free_entry(dat, req);
···
336
336
{
337
337
struct buffer_head *entry_bh;
338
338
struct nilfs_dat_entry *entry;
339
-
void *kaddr;
339
+
size_t offset;
340
340
int ret;
341
341
342
342
ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
···
359
359
}
360
360
}
361
361
362
-
kaddr = kmap_local_page(entry_bh->b_page);
363
-
entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
362
+
offset = nilfs_palloc_entry_offset(dat, vblocknr, entry_bh);
363
+
entry = kmap_local_folio(entry_bh->b_folio, offset);
364
364
if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
365
365
nilfs_crit(dat->i_sb,
366
366
"%s: invalid vblocknr = %llu, [%llu, %llu)",
367
367
__func__, (unsigned long long)vblocknr,
368
368
(unsigned long long)le64_to_cpu(entry->de_start),
369
369
(unsigned long long)le64_to_cpu(entry->de_end));
370
-
kunmap_local(kaddr);
370
+
kunmap_local(entry);
371
371
brelse(entry_bh);
372
372
return -EINVAL;
373
373
}
374
374
WARN_ON(blocknr == 0);
375
375
entry->de_blocknr = cpu_to_le64(blocknr);
376
-
kunmap_local(kaddr);
376
+
kunmap_local(entry);
377
377
378
378
mark_buffer_dirty(entry_bh);
379
379
nilfs_mdt_mark_dirty(dat);
···
407
407
struct buffer_head *entry_bh, *bh;
408
408
struct nilfs_dat_entry *entry;
409
409
sector_t blocknr;
410
-
void *kaddr;
410
+
size_t offset;
411
411
int ret;
412
412
413
413
ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
···
423
423
}
424
424
}
425
425
426
-
kaddr = kmap_local_page(entry_bh->b_page);
427
-
entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
426
+
offset = nilfs_palloc_entry_offset(dat, vblocknr, entry_bh);
427
+
entry = kmap_local_folio(entry_bh->b_folio, offset);
428
428
blocknr = le64_to_cpu(entry->de_blocknr);
429
429
if (blocknr == 0) {
430
430
ret = -ENOENT;
···
433
433
*blocknrp = blocknr;
434
434
435
435
out:
436
-
kunmap_local(kaddr);
436
+
kunmap_local(entry);
437
437
brelse(entry_bh);
438
438
return ret;
439
439
}
···
442
442
size_t nvi)
443
443
{
444
444
struct buffer_head *entry_bh;
445
-
struct nilfs_dat_entry *entry;
445
+
struct nilfs_dat_entry *entry, *first_entry;
446
446
struct nilfs_vinfo *vinfo = buf;
447
447
__u64 first, last;
448
-
void *kaddr;
448
+
size_t offset;
449
449
unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
450
+
unsigned int entry_size = NILFS_MDT(dat)->mi_entry_size;
450
451
int i, j, n, ret;
451
452
452
453
for (i = 0; i < nvi; i += n) {
···
455
454
0, &entry_bh);
456
455
if (ret < 0)
457
456
return ret;
458
-
kaddr = kmap_local_page(entry_bh->b_page);
459
-
/* last virtual block number in this block */
457
+
460
458
first = vinfo->vi_vblocknr;
461
459
first = div64_ul(first, entries_per_block);
462
460
first *= entries_per_block;
461
+
/* first virtual block number in this block */
462
+
463
463
last = first + entries_per_block - 1;
464
+
/* last virtual block number in this block */
465
+
466
+
offset = nilfs_palloc_entry_offset(dat, first, entry_bh);
467
+
first_entry = kmap_local_folio(entry_bh->b_folio, offset);
464
468
for (j = i, n = 0;
465
469
j < nvi && vinfo->vi_vblocknr >= first &&
466
470
vinfo->vi_vblocknr <= last;
467
471
j++, n++, vinfo = (void *)vinfo + visz) {
468
-
entry = nilfs_palloc_block_get_entry(
469
-
dat, vinfo->vi_vblocknr, entry_bh, kaddr);
472
+
entry = (void *)first_entry +
473
+
(vinfo->vi_vblocknr - first) * entry_size;
470
474
vinfo->vi_start = le64_to_cpu(entry->de_start);
471
475
vinfo->vi_end = le64_to_cpu(entry->de_end);
472
476
vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
473
477
}
474
-
kunmap_local(kaddr);
478
+
kunmap_local(first_entry);
475
479
brelse(entry_bh);
476
480
}
477
481