forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1215 lines
32 KiB
1215 lines
32 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* sufile.c - NILFS segment usage file. |
|
* |
|
* Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation. |
|
* |
|
* Written by Koji Sato. |
|
* Revised by Ryusuke Konishi. |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/fs.h> |
|
#include <linux/string.h> |
|
#include <linux/buffer_head.h> |
|
#include <linux/errno.h> |
|
#include "mdt.h" |
|
#include "sufile.h" |
|
|
|
#include <trace/events/nilfs2.h> |
|
|
|
/** |
|
* struct nilfs_sufile_info - on-memory private data of sufile |
|
* @mi: on-memory private data of metadata file |
|
* @ncleansegs: number of clean segments |
|
* @allocmin: lower limit of allocatable segment range |
|
* @allocmax: upper limit of allocatable segment range |
|
*/ |
|
struct nilfs_sufile_info { |
|
struct nilfs_mdt_info mi; |
|
unsigned long ncleansegs;/* number of clean segments */ |
|
__u64 allocmin; /* lower limit of allocatable segment range */ |
|
__u64 allocmax; /* upper limit of allocatable segment range */ |
|
}; |
|
|
|
static inline struct nilfs_sufile_info *NILFS_SUI(struct inode *sufile) |
|
{ |
|
return (struct nilfs_sufile_info *)NILFS_MDT(sufile); |
|
} |
|
|
|
static inline unsigned long |
|
nilfs_sufile_segment_usages_per_block(const struct inode *sufile) |
|
{ |
|
return NILFS_MDT(sufile)->mi_entries_per_block; |
|
} |
|
|
|
static unsigned long |
|
nilfs_sufile_get_blkoff(const struct inode *sufile, __u64 segnum) |
|
{ |
|
__u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset; |
|
|
|
do_div(t, nilfs_sufile_segment_usages_per_block(sufile)); |
|
return (unsigned long)t; |
|
} |
|
|
|
static unsigned long |
|
nilfs_sufile_get_offset(const struct inode *sufile, __u64 segnum) |
|
{ |
|
__u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset; |
|
|
|
return do_div(t, nilfs_sufile_segment_usages_per_block(sufile)); |
|
} |
|
|
|
static unsigned long |
|
nilfs_sufile_segment_usages_in_block(const struct inode *sufile, __u64 curr, |
|
__u64 max) |
|
{ |
|
return min_t(unsigned long, |
|
nilfs_sufile_segment_usages_per_block(sufile) - |
|
nilfs_sufile_get_offset(sufile, curr), |
|
max - curr + 1); |
|
} |
|
|
|
static struct nilfs_segment_usage * |
|
nilfs_sufile_block_get_segment_usage(const struct inode *sufile, __u64 segnum, |
|
struct buffer_head *bh, void *kaddr) |
|
{ |
|
return kaddr + bh_offset(bh) + |
|
nilfs_sufile_get_offset(sufile, segnum) * |
|
NILFS_MDT(sufile)->mi_entry_size; |
|
} |
|
|
|
static inline int nilfs_sufile_get_header_block(struct inode *sufile, |
|
struct buffer_head **bhp) |
|
{ |
|
return nilfs_mdt_get_block(sufile, 0, 0, NULL, bhp); |
|
} |
|
|
|
static inline int |
|
nilfs_sufile_get_segment_usage_block(struct inode *sufile, __u64 segnum, |
|
int create, struct buffer_head **bhp) |
|
{ |
|
return nilfs_mdt_get_block(sufile, |
|
nilfs_sufile_get_blkoff(sufile, segnum), |
|
create, NULL, bhp); |
|
} |
|
|
|
static int nilfs_sufile_delete_segment_usage_block(struct inode *sufile, |
|
__u64 segnum) |
|
{ |
|
return nilfs_mdt_delete_block(sufile, |
|
nilfs_sufile_get_blkoff(sufile, segnum)); |
|
} |
|
|
|
static void nilfs_sufile_mod_counter(struct buffer_head *header_bh, |
|
u64 ncleanadd, u64 ndirtyadd) |
|
{ |
|
struct nilfs_sufile_header *header; |
|
void *kaddr; |
|
|
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
le64_add_cpu(&header->sh_ncleansegs, ncleanadd); |
|
le64_add_cpu(&header->sh_ndirtysegs, ndirtyadd); |
|
kunmap_atomic(kaddr); |
|
|
|
mark_buffer_dirty(header_bh); |
|
} |
|
|
|
/** |
|
* nilfs_sufile_get_ncleansegs - return the number of clean segments |
|
* @sufile: inode of segment usage file |
|
*/ |
|
unsigned long nilfs_sufile_get_ncleansegs(struct inode *sufile) |
|
{ |
|
return NILFS_SUI(sufile)->ncleansegs; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_updatev - modify multiple segment usages at a time |
|
* @sufile: inode of segment usage file |
|
* @segnumv: array of segment numbers |
|
* @nsegs: size of @segnumv array |
|
* @create: creation flag |
|
* @ndone: place to store number of modified segments on @segnumv |
|
* @dofunc: primitive operation for the update |
|
* |
|
* Description: nilfs_sufile_updatev() repeatedly calls @dofunc |
|
* against the given array of segments. The @dofunc is called with |
|
* buffers of a header block and the sufile block in which the target |
|
* segment usage entry is contained. If @ndone is given, the number |
|
* of successfully modified segments from the head is stored in the |
|
* place @ndone points to. |
|
* |
|
* Return Value: On success, zero is returned. On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
* |
|
* %-ENOENT - Given segment usage is in hole block (may be returned if |
|
* @create is zero) |
|
* |
|
* %-EINVAL - Invalid segment usage number |
|
*/ |
|
int nilfs_sufile_updatev(struct inode *sufile, __u64 *segnumv, size_t nsegs, |
|
int create, size_t *ndone, |
|
void (*dofunc)(struct inode *, __u64, |
|
struct buffer_head *, |
|
struct buffer_head *)) |
|
{ |
|
struct buffer_head *header_bh, *bh; |
|
unsigned long blkoff, prev_blkoff; |
|
__u64 *seg; |
|
size_t nerr = 0, n = 0; |
|
int ret = 0; |
|
|
|
if (unlikely(nsegs == 0)) |
|
goto out; |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
for (seg = segnumv; seg < segnumv + nsegs; seg++) { |
|
if (unlikely(*seg >= nilfs_sufile_get_nsegments(sufile))) { |
|
nilfs_warn(sufile->i_sb, |
|
"%s: invalid segment number: %llu", |
|
__func__, (unsigned long long)*seg); |
|
nerr++; |
|
} |
|
} |
|
if (nerr > 0) { |
|
ret = -EINVAL; |
|
goto out_sem; |
|
} |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
|
|
seg = segnumv; |
|
blkoff = nilfs_sufile_get_blkoff(sufile, *seg); |
|
ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh); |
|
if (ret < 0) |
|
goto out_header; |
|
|
|
for (;;) { |
|
dofunc(sufile, *seg, header_bh, bh); |
|
|
|
if (++seg >= segnumv + nsegs) |
|
break; |
|
prev_blkoff = blkoff; |
|
blkoff = nilfs_sufile_get_blkoff(sufile, *seg); |
|
if (blkoff == prev_blkoff) |
|
continue; |
|
|
|
/* get different block */ |
|
brelse(bh); |
|
ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh); |
|
if (unlikely(ret < 0)) |
|
goto out_header; |
|
} |
|
brelse(bh); |
|
|
|
out_header: |
|
n = seg - segnumv; |
|
brelse(header_bh); |
|
out_sem: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
out: |
|
if (ndone) |
|
*ndone = n; |
|
return ret; |
|
} |
|
|
|
int nilfs_sufile_update(struct inode *sufile, __u64 segnum, int create, |
|
void (*dofunc)(struct inode *, __u64, |
|
struct buffer_head *, |
|
struct buffer_head *)) |
|
{ |
|
struct buffer_head *header_bh, *bh; |
|
int ret; |
|
|
|
if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) { |
|
nilfs_warn(sufile->i_sb, "%s: invalid segment number: %llu", |
|
__func__, (unsigned long long)segnum); |
|
return -EINVAL; |
|
} |
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
|
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, create, &bh); |
|
if (!ret) { |
|
dofunc(sufile, segnum, header_bh, bh); |
|
brelse(bh); |
|
} |
|
brelse(header_bh); |
|
|
|
out_sem: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_set_alloc_range - limit range of segment to be allocated |
|
* @sufile: inode of segment usage file |
|
* @start: minimum segment number of allocatable region (inclusive) |
|
* @end: maximum segment number of allocatable region (inclusive) |
|
* |
|
* Return Value: On success, 0 is returned. On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-ERANGE - invalid segment region |
|
*/ |
|
int nilfs_sufile_set_alloc_range(struct inode *sufile, __u64 start, __u64 end) |
|
{ |
|
struct nilfs_sufile_info *sui = NILFS_SUI(sufile); |
|
__u64 nsegs; |
|
int ret = -ERANGE; |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
nsegs = nilfs_sufile_get_nsegments(sufile); |
|
|
|
if (start <= end && end < nsegs) { |
|
sui->allocmin = start; |
|
sui->allocmax = end; |
|
ret = 0; |
|
} |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_alloc - allocate a segment |
|
* @sufile: inode of segment usage file |
|
* @segnump: pointer to segment number |
|
* |
|
* Description: nilfs_sufile_alloc() allocates a clean segment. |
|
* |
|
* Return Value: On success, 0 is returned and the segment number of the |
|
* allocated segment is stored in the place pointed by @segnump. On error, one |
|
* of the following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
* |
|
* %-ENOSPC - No clean segment left. |
|
*/ |
|
int nilfs_sufile_alloc(struct inode *sufile, __u64 *segnump) |
|
{ |
|
struct buffer_head *header_bh, *su_bh; |
|
struct nilfs_sufile_header *header; |
|
struct nilfs_segment_usage *su; |
|
struct nilfs_sufile_info *sui = NILFS_SUI(sufile); |
|
size_t susz = NILFS_MDT(sufile)->mi_entry_size; |
|
__u64 segnum, maxsegnum, last_alloc; |
|
void *kaddr; |
|
unsigned long nsegments, nsus, cnt; |
|
int ret, j; |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
last_alloc = le64_to_cpu(header->sh_last_alloc); |
|
kunmap_atomic(kaddr); |
|
|
|
nsegments = nilfs_sufile_get_nsegments(sufile); |
|
maxsegnum = sui->allocmax; |
|
segnum = last_alloc + 1; |
|
if (segnum < sui->allocmin || segnum > sui->allocmax) |
|
segnum = sui->allocmin; |
|
|
|
for (cnt = 0; cnt < nsegments; cnt += nsus) { |
|
if (segnum > maxsegnum) { |
|
if (cnt < sui->allocmax - sui->allocmin + 1) { |
|
/* |
|
* wrap around in the limited region. |
|
* if allocation started from |
|
* sui->allocmin, this never happens. |
|
*/ |
|
segnum = sui->allocmin; |
|
maxsegnum = last_alloc; |
|
} else if (segnum > sui->allocmin && |
|
sui->allocmax + 1 < nsegments) { |
|
segnum = sui->allocmax + 1; |
|
maxsegnum = nsegments - 1; |
|
} else if (sui->allocmin > 0) { |
|
segnum = 0; |
|
maxsegnum = sui->allocmin - 1; |
|
} else { |
|
break; /* never happens */ |
|
} |
|
} |
|
trace_nilfs2_segment_usage_check(sufile, segnum, cnt); |
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 1, |
|
&su_bh); |
|
if (ret < 0) |
|
goto out_header; |
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage( |
|
sufile, segnum, su_bh, kaddr); |
|
|
|
nsus = nilfs_sufile_segment_usages_in_block( |
|
sufile, segnum, maxsegnum); |
|
for (j = 0; j < nsus; j++, su = (void *)su + susz, segnum++) { |
|
if (!nilfs_segment_usage_clean(su)) |
|
continue; |
|
/* found a clean segment */ |
|
nilfs_segment_usage_set_dirty(su); |
|
kunmap_atomic(kaddr); |
|
|
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
le64_add_cpu(&header->sh_ncleansegs, -1); |
|
le64_add_cpu(&header->sh_ndirtysegs, 1); |
|
header->sh_last_alloc = cpu_to_le64(segnum); |
|
kunmap_atomic(kaddr); |
|
|
|
sui->ncleansegs--; |
|
mark_buffer_dirty(header_bh); |
|
mark_buffer_dirty(su_bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
brelse(su_bh); |
|
*segnump = segnum; |
|
|
|
trace_nilfs2_segment_usage_allocated(sufile, segnum); |
|
|
|
goto out_header; |
|
} |
|
|
|
kunmap_atomic(kaddr); |
|
brelse(su_bh); |
|
} |
|
|
|
/* no segments left */ |
|
ret = -ENOSPC; |
|
|
|
out_header: |
|
brelse(header_bh); |
|
|
|
out_sem: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum, |
|
struct buffer_head *header_bh, |
|
struct buffer_head *su_bh) |
|
{ |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr); |
|
if (unlikely(!nilfs_segment_usage_clean(su))) { |
|
nilfs_warn(sufile->i_sb, "%s: segment %llu must be clean", |
|
__func__, (unsigned long long)segnum); |
|
kunmap_atomic(kaddr); |
|
return; |
|
} |
|
nilfs_segment_usage_set_dirty(su); |
|
kunmap_atomic(kaddr); |
|
|
|
nilfs_sufile_mod_counter(header_bh, -1, 1); |
|
NILFS_SUI(sufile)->ncleansegs--; |
|
|
|
mark_buffer_dirty(su_bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
} |
|
|
|
void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum, |
|
struct buffer_head *header_bh, |
|
struct buffer_head *su_bh) |
|
{ |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
int clean, dirty; |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr); |
|
if (su->su_flags == cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY)) && |
|
su->su_nblocks == cpu_to_le32(0)) { |
|
kunmap_atomic(kaddr); |
|
return; |
|
} |
|
clean = nilfs_segment_usage_clean(su); |
|
dirty = nilfs_segment_usage_dirty(su); |
|
|
|
/* make the segment garbage */ |
|
su->su_lastmod = cpu_to_le64(0); |
|
su->su_nblocks = cpu_to_le32(0); |
|
su->su_flags = cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY)); |
|
kunmap_atomic(kaddr); |
|
|
|
nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1); |
|
NILFS_SUI(sufile)->ncleansegs -= clean; |
|
|
|
mark_buffer_dirty(su_bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
} |
|
|
|
void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum, |
|
struct buffer_head *header_bh, |
|
struct buffer_head *su_bh) |
|
{ |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
int sudirty; |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr); |
|
if (nilfs_segment_usage_clean(su)) { |
|
nilfs_warn(sufile->i_sb, "%s: segment %llu is already clean", |
|
__func__, (unsigned long long)segnum); |
|
kunmap_atomic(kaddr); |
|
return; |
|
} |
|
WARN_ON(nilfs_segment_usage_error(su)); |
|
WARN_ON(!nilfs_segment_usage_dirty(su)); |
|
|
|
sudirty = nilfs_segment_usage_dirty(su); |
|
nilfs_segment_usage_set_clean(su); |
|
kunmap_atomic(kaddr); |
|
mark_buffer_dirty(su_bh); |
|
|
|
nilfs_sufile_mod_counter(header_bh, 1, sudirty ? (u64)-1 : 0); |
|
NILFS_SUI(sufile)->ncleansegs++; |
|
|
|
nilfs_mdt_mark_dirty(sufile); |
|
|
|
trace_nilfs2_segment_usage_freed(sufile, segnum); |
|
} |
|
|
|
/** |
|
* nilfs_sufile_mark_dirty - mark the buffer having a segment usage dirty |
|
* @sufile: inode of segment usage file |
|
* @segnum: segment number |
|
*/ |
|
int nilfs_sufile_mark_dirty(struct inode *sufile, __u64 segnum) |
|
{ |
|
struct buffer_head *bh; |
|
int ret; |
|
|
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh); |
|
if (!ret) { |
|
mark_buffer_dirty(bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
brelse(bh); |
|
} |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_set_segment_usage - set usage of a segment |
|
* @sufile: inode of segment usage file |
|
* @segnum: segment number |
|
* @nblocks: number of live blocks in the segment |
|
* @modtime: modification time (option) |
|
*/ |
|
int nilfs_sufile_set_segment_usage(struct inode *sufile, __u64 segnum, |
|
unsigned long nblocks, time64_t modtime) |
|
{ |
|
struct buffer_head *bh; |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
int ret; |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
|
|
kaddr = kmap_atomic(bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr); |
|
WARN_ON(nilfs_segment_usage_error(su)); |
|
if (modtime) |
|
su->su_lastmod = cpu_to_le64(modtime); |
|
su->su_nblocks = cpu_to_le32(nblocks); |
|
kunmap_atomic(kaddr); |
|
|
|
mark_buffer_dirty(bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
brelse(bh); |
|
|
|
out_sem: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_get_stat - get segment usage statistics |
|
* @sufile: inode of segment usage file |
|
* @sustat: pointer to a structure of segment usage statistics |
|
* |
|
* Description: nilfs_sufile_get_stat() returns information about segment |
|
* usage. |
|
* |
|
* Return Value: On success, 0 is returned, and segment usage information is |
|
* stored in the place pointed by @sustat. On error, one of the following |
|
* negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
*/ |
|
int nilfs_sufile_get_stat(struct inode *sufile, struct nilfs_sustat *sustat) |
|
{ |
|
struct buffer_head *header_bh; |
|
struct nilfs_sufile_header *header; |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
void *kaddr; |
|
int ret; |
|
|
|
down_read(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
|
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
sustat->ss_nsegs = nilfs_sufile_get_nsegments(sufile); |
|
sustat->ss_ncleansegs = le64_to_cpu(header->sh_ncleansegs); |
|
sustat->ss_ndirtysegs = le64_to_cpu(header->sh_ndirtysegs); |
|
sustat->ss_ctime = nilfs->ns_ctime; |
|
sustat->ss_nongc_ctime = nilfs->ns_nongc_ctime; |
|
spin_lock(&nilfs->ns_last_segment_lock); |
|
sustat->ss_prot_seq = nilfs->ns_prot_seq; |
|
spin_unlock(&nilfs->ns_last_segment_lock); |
|
kunmap_atomic(kaddr); |
|
brelse(header_bh); |
|
|
|
out_sem: |
|
up_read(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum, |
|
struct buffer_head *header_bh, |
|
struct buffer_head *su_bh) |
|
{ |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
int suclean; |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr); |
|
if (nilfs_segment_usage_error(su)) { |
|
kunmap_atomic(kaddr); |
|
return; |
|
} |
|
suclean = nilfs_segment_usage_clean(su); |
|
nilfs_segment_usage_set_error(su); |
|
kunmap_atomic(kaddr); |
|
|
|
if (suclean) { |
|
nilfs_sufile_mod_counter(header_bh, -1, 0); |
|
NILFS_SUI(sufile)->ncleansegs--; |
|
} |
|
mark_buffer_dirty(su_bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
} |
|
|
|
/** |
|
* nilfs_sufile_truncate_range - truncate range of segment array |
|
* @sufile: inode of segment usage file |
|
* @start: start segment number (inclusive) |
|
* @end: end segment number (inclusive) |
|
* |
|
* Return Value: On success, 0 is returned. On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
* |
|
* %-EINVAL - Invalid number of segments specified |
|
* |
|
* %-EBUSY - Dirty or active segments are present in the range |
|
*/ |
|
static int nilfs_sufile_truncate_range(struct inode *sufile, |
|
__u64 start, __u64 end) |
|
{ |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
struct buffer_head *header_bh; |
|
struct buffer_head *su_bh; |
|
struct nilfs_segment_usage *su, *su2; |
|
size_t susz = NILFS_MDT(sufile)->mi_entry_size; |
|
unsigned long segusages_per_block; |
|
unsigned long nsegs, ncleaned; |
|
__u64 segnum; |
|
void *kaddr; |
|
ssize_t n, nc; |
|
int ret; |
|
int j; |
|
|
|
nsegs = nilfs_sufile_get_nsegments(sufile); |
|
|
|
ret = -EINVAL; |
|
if (start > end || start >= nsegs) |
|
goto out; |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out; |
|
|
|
segusages_per_block = nilfs_sufile_segment_usages_per_block(sufile); |
|
ncleaned = 0; |
|
|
|
for (segnum = start; segnum <= end; segnum += n) { |
|
n = min_t(unsigned long, |
|
segusages_per_block - |
|
nilfs_sufile_get_offset(sufile, segnum), |
|
end - segnum + 1); |
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, |
|
&su_bh); |
|
if (ret < 0) { |
|
if (ret != -ENOENT) |
|
goto out_header; |
|
/* hole */ |
|
continue; |
|
} |
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage( |
|
sufile, segnum, su_bh, kaddr); |
|
su2 = su; |
|
for (j = 0; j < n; j++, su = (void *)su + susz) { |
|
if ((le32_to_cpu(su->su_flags) & |
|
~BIT(NILFS_SEGMENT_USAGE_ERROR)) || |
|
nilfs_segment_is_active(nilfs, segnum + j)) { |
|
ret = -EBUSY; |
|
kunmap_atomic(kaddr); |
|
brelse(su_bh); |
|
goto out_header; |
|
} |
|
} |
|
nc = 0; |
|
for (su = su2, j = 0; j < n; j++, su = (void *)su + susz) { |
|
if (nilfs_segment_usage_error(su)) { |
|
nilfs_segment_usage_set_clean(su); |
|
nc++; |
|
} |
|
} |
|
kunmap_atomic(kaddr); |
|
if (nc > 0) { |
|
mark_buffer_dirty(su_bh); |
|
ncleaned += nc; |
|
} |
|
brelse(su_bh); |
|
|
|
if (n == segusages_per_block) { |
|
/* make hole */ |
|
nilfs_sufile_delete_segment_usage_block(sufile, segnum); |
|
} |
|
} |
|
ret = 0; |
|
|
|
out_header: |
|
if (ncleaned > 0) { |
|
NILFS_SUI(sufile)->ncleansegs += ncleaned; |
|
nilfs_sufile_mod_counter(header_bh, ncleaned, 0); |
|
nilfs_mdt_mark_dirty(sufile); |
|
} |
|
brelse(header_bh); |
|
out: |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_resize - resize segment array |
|
* @sufile: inode of segment usage file |
|
* @newnsegs: new number of segments |
|
* |
|
* Return Value: On success, 0 is returned. On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
* |
|
* %-ENOSPC - Enough free space is not left for shrinking |
|
* |
|
* %-EBUSY - Dirty or active segments exist in the region to be truncated |
|
*/ |
|
int nilfs_sufile_resize(struct inode *sufile, __u64 newnsegs) |
|
{ |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
struct buffer_head *header_bh; |
|
struct nilfs_sufile_header *header; |
|
struct nilfs_sufile_info *sui = NILFS_SUI(sufile); |
|
void *kaddr; |
|
unsigned long nsegs, nrsvsegs; |
|
int ret = 0; |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
nsegs = nilfs_sufile_get_nsegments(sufile); |
|
if (nsegs == newnsegs) |
|
goto out; |
|
|
|
ret = -ENOSPC; |
|
nrsvsegs = nilfs_nrsvsegs(nilfs, newnsegs); |
|
if (newnsegs < nsegs && nsegs - newnsegs + nrsvsegs > sui->ncleansegs) |
|
goto out; |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out; |
|
|
|
if (newnsegs > nsegs) { |
|
sui->ncleansegs += newnsegs - nsegs; |
|
} else /* newnsegs < nsegs */ { |
|
ret = nilfs_sufile_truncate_range(sufile, newnsegs, nsegs - 1); |
|
if (ret < 0) |
|
goto out_header; |
|
|
|
sui->ncleansegs -= nsegs - newnsegs; |
|
} |
|
|
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
header->sh_ncleansegs = cpu_to_le64(sui->ncleansegs); |
|
kunmap_atomic(kaddr); |
|
|
|
mark_buffer_dirty(header_bh); |
|
nilfs_mdt_mark_dirty(sufile); |
|
nilfs_set_nsegments(nilfs, newnsegs); |
|
|
|
out_header: |
|
brelse(header_bh); |
|
out: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_get_suinfo - |
|
* @sufile: inode of segment usage file |
|
* @segnum: segment number to start looking |
|
* @buf: array of suinfo |
|
* @sisz: byte size of suinfo |
|
* @nsi: size of suinfo array |
|
* |
|
* Description: |
|
* |
|
* Return Value: On success, 0 is returned and .... On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
*/ |
|
ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf, |
|
unsigned int sisz, size_t nsi) |
|
{ |
|
struct buffer_head *su_bh; |
|
struct nilfs_segment_usage *su; |
|
struct nilfs_suinfo *si = buf; |
|
size_t susz = NILFS_MDT(sufile)->mi_entry_size; |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
void *kaddr; |
|
unsigned long nsegs, segusages_per_block; |
|
ssize_t n; |
|
int ret, i, j; |
|
|
|
down_read(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
segusages_per_block = nilfs_sufile_segment_usages_per_block(sufile); |
|
nsegs = min_t(unsigned long, |
|
nilfs_sufile_get_nsegments(sufile) - segnum, |
|
nsi); |
|
for (i = 0; i < nsegs; i += n, segnum += n) { |
|
n = min_t(unsigned long, |
|
segusages_per_block - |
|
nilfs_sufile_get_offset(sufile, segnum), |
|
nsegs - i); |
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, |
|
&su_bh); |
|
if (ret < 0) { |
|
if (ret != -ENOENT) |
|
goto out; |
|
/* hole */ |
|
memset(si, 0, sisz * n); |
|
si = (void *)si + sisz * n; |
|
continue; |
|
} |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage( |
|
sufile, segnum, su_bh, kaddr); |
|
for (j = 0; j < n; |
|
j++, su = (void *)su + susz, si = (void *)si + sisz) { |
|
si->sui_lastmod = le64_to_cpu(su->su_lastmod); |
|
si->sui_nblocks = le32_to_cpu(su->su_nblocks); |
|
si->sui_flags = le32_to_cpu(su->su_flags) & |
|
~BIT(NILFS_SEGMENT_USAGE_ACTIVE); |
|
if (nilfs_segment_is_active(nilfs, segnum + j)) |
|
si->sui_flags |= |
|
BIT(NILFS_SEGMENT_USAGE_ACTIVE); |
|
} |
|
kunmap_atomic(kaddr); |
|
brelse(su_bh); |
|
} |
|
ret = nsegs; |
|
|
|
out: |
|
up_read(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_set_suinfo - sets segment usage info |
|
* @sufile: inode of segment usage file |
|
* @buf: array of suinfo_update |
|
* @supsz: byte size of suinfo_update |
|
* @nsup: size of suinfo_update array |
|
* |
|
* Description: Takes an array of nilfs_suinfo_update structs and updates |
|
* segment usage accordingly. Only the fields indicated by the sup_flags |
|
* are updated. |
|
* |
|
* Return Value: On success, 0 is returned. On error, one of the |
|
* following negative error codes is returned. |
|
* |
|
* %-EIO - I/O error. |
|
* |
|
* %-ENOMEM - Insufficient amount of memory available. |
|
* |
|
* %-EINVAL - Invalid values in input (segment number, flags or nblocks) |
|
*/ |
|
ssize_t nilfs_sufile_set_suinfo(struct inode *sufile, void *buf, |
|
unsigned int supsz, size_t nsup) |
|
{ |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
struct buffer_head *header_bh, *bh; |
|
struct nilfs_suinfo_update *sup, *supend = buf + supsz * nsup; |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
unsigned long blkoff, prev_blkoff; |
|
int cleansi, cleansu, dirtysi, dirtysu; |
|
long ncleaned = 0, ndirtied = 0; |
|
int ret = 0; |
|
|
|
if (unlikely(nsup == 0)) |
|
return ret; |
|
|
|
for (sup = buf; sup < supend; sup = (void *)sup + supsz) { |
|
if (sup->sup_segnum >= nilfs->ns_nsegments |
|
|| (sup->sup_flags & |
|
(~0UL << __NR_NILFS_SUINFO_UPDATE_FIELDS)) |
|
|| (nilfs_suinfo_update_nblocks(sup) && |
|
sup->sup_sui.sui_nblocks > |
|
nilfs->ns_blocks_per_segment)) |
|
return -EINVAL; |
|
} |
|
|
|
down_write(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
ret = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (ret < 0) |
|
goto out_sem; |
|
|
|
sup = buf; |
|
blkoff = nilfs_sufile_get_blkoff(sufile, sup->sup_segnum); |
|
ret = nilfs_mdt_get_block(sufile, blkoff, 1, NULL, &bh); |
|
if (ret < 0) |
|
goto out_header; |
|
|
|
for (;;) { |
|
kaddr = kmap_atomic(bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage( |
|
sufile, sup->sup_segnum, bh, kaddr); |
|
|
|
if (nilfs_suinfo_update_lastmod(sup)) |
|
su->su_lastmod = cpu_to_le64(sup->sup_sui.sui_lastmod); |
|
|
|
if (nilfs_suinfo_update_nblocks(sup)) |
|
su->su_nblocks = cpu_to_le32(sup->sup_sui.sui_nblocks); |
|
|
|
if (nilfs_suinfo_update_flags(sup)) { |
|
/* |
|
* Active flag is a virtual flag projected by running |
|
* nilfs kernel code - drop it not to write it to |
|
* disk. |
|
*/ |
|
sup->sup_sui.sui_flags &= |
|
~BIT(NILFS_SEGMENT_USAGE_ACTIVE); |
|
|
|
cleansi = nilfs_suinfo_clean(&sup->sup_sui); |
|
cleansu = nilfs_segment_usage_clean(su); |
|
dirtysi = nilfs_suinfo_dirty(&sup->sup_sui); |
|
dirtysu = nilfs_segment_usage_dirty(su); |
|
|
|
if (cleansi && !cleansu) |
|
++ncleaned; |
|
else if (!cleansi && cleansu) |
|
--ncleaned; |
|
|
|
if (dirtysi && !dirtysu) |
|
++ndirtied; |
|
else if (!dirtysi && dirtysu) |
|
--ndirtied; |
|
|
|
su->su_flags = cpu_to_le32(sup->sup_sui.sui_flags); |
|
} |
|
|
|
kunmap_atomic(kaddr); |
|
|
|
sup = (void *)sup + supsz; |
|
if (sup >= supend) |
|
break; |
|
|
|
prev_blkoff = blkoff; |
|
blkoff = nilfs_sufile_get_blkoff(sufile, sup->sup_segnum); |
|
if (blkoff == prev_blkoff) |
|
continue; |
|
|
|
/* get different block */ |
|
mark_buffer_dirty(bh); |
|
put_bh(bh); |
|
ret = nilfs_mdt_get_block(sufile, blkoff, 1, NULL, &bh); |
|
if (unlikely(ret < 0)) |
|
goto out_mark; |
|
} |
|
mark_buffer_dirty(bh); |
|
put_bh(bh); |
|
|
|
out_mark: |
|
if (ncleaned || ndirtied) { |
|
nilfs_sufile_mod_counter(header_bh, (u64)ncleaned, |
|
(u64)ndirtied); |
|
NILFS_SUI(sufile)->ncleansegs += ncleaned; |
|
} |
|
nilfs_mdt_mark_dirty(sufile); |
|
out_header: |
|
put_bh(header_bh); |
|
out_sem: |
|
up_write(&NILFS_MDT(sufile)->mi_sem); |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_trim_fs() - trim ioctl handle function |
|
* @sufile: inode of segment usage file |
|
* @range: fstrim_range structure |
|
* |
|
* start: First Byte to trim |
|
* len: number of Bytes to trim from start |
|
* minlen: minimum extent length in Bytes |
|
* |
|
* Decription: nilfs_sufile_trim_fs goes through all segments containing bytes |
|
* from start to start+len. start is rounded up to the next block boundary |
|
* and start+len is rounded down. For each clean segment blkdev_issue_discard |
|
* function is invoked. |
|
* |
|
* Return Value: On success, 0 is returned or negative error code, otherwise. |
|
*/ |
|
int nilfs_sufile_trim_fs(struct inode *sufile, struct fstrim_range *range) |
|
{ |
|
struct the_nilfs *nilfs = sufile->i_sb->s_fs_info; |
|
struct buffer_head *su_bh; |
|
struct nilfs_segment_usage *su; |
|
void *kaddr; |
|
size_t n, i, susz = NILFS_MDT(sufile)->mi_entry_size; |
|
sector_t seg_start, seg_end, start_block, end_block; |
|
sector_t start = 0, nblocks = 0; |
|
u64 segnum, segnum_end, minlen, len, max_blocks, ndiscarded = 0; |
|
int ret = 0; |
|
unsigned int sects_per_block; |
|
|
|
sects_per_block = (1 << nilfs->ns_blocksize_bits) / |
|
bdev_logical_block_size(nilfs->ns_bdev); |
|
len = range->len >> nilfs->ns_blocksize_bits; |
|
minlen = range->minlen >> nilfs->ns_blocksize_bits; |
|
max_blocks = ((u64)nilfs->ns_nsegments * nilfs->ns_blocks_per_segment); |
|
|
|
if (!len || range->start >= max_blocks << nilfs->ns_blocksize_bits) |
|
return -EINVAL; |
|
|
|
start_block = (range->start + nilfs->ns_blocksize - 1) >> |
|
nilfs->ns_blocksize_bits; |
|
|
|
/* |
|
* range->len can be very large (actually, it is set to |
|
* ULLONG_MAX by default) - truncate upper end of the range |
|
* carefully so as not to overflow. |
|
*/ |
|
if (max_blocks - start_block < len) |
|
end_block = max_blocks - 1; |
|
else |
|
end_block = start_block + len - 1; |
|
|
|
segnum = nilfs_get_segnum_of_block(nilfs, start_block); |
|
segnum_end = nilfs_get_segnum_of_block(nilfs, end_block); |
|
|
|
down_read(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
while (segnum <= segnum_end) { |
|
n = nilfs_sufile_segment_usages_in_block(sufile, segnum, |
|
segnum_end); |
|
|
|
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, |
|
&su_bh); |
|
if (ret < 0) { |
|
if (ret != -ENOENT) |
|
goto out_sem; |
|
/* hole */ |
|
segnum += n; |
|
continue; |
|
} |
|
|
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, |
|
su_bh, kaddr); |
|
for (i = 0; i < n; ++i, ++segnum, su = (void *)su + susz) { |
|
if (!nilfs_segment_usage_clean(su)) |
|
continue; |
|
|
|
nilfs_get_segment_range(nilfs, segnum, &seg_start, |
|
&seg_end); |
|
|
|
if (!nblocks) { |
|
/* start new extent */ |
|
start = seg_start; |
|
nblocks = seg_end - seg_start + 1; |
|
continue; |
|
} |
|
|
|
if (start + nblocks == seg_start) { |
|
/* add to previous extent */ |
|
nblocks += seg_end - seg_start + 1; |
|
continue; |
|
} |
|
|
|
/* discard previous extent */ |
|
if (start < start_block) { |
|
nblocks -= start_block - start; |
|
start = start_block; |
|
} |
|
|
|
if (nblocks >= minlen) { |
|
kunmap_atomic(kaddr); |
|
|
|
ret = blkdev_issue_discard(nilfs->ns_bdev, |
|
start * sects_per_block, |
|
nblocks * sects_per_block, |
|
GFP_NOFS, 0); |
|
if (ret < 0) { |
|
put_bh(su_bh); |
|
goto out_sem; |
|
} |
|
|
|
ndiscarded += nblocks; |
|
kaddr = kmap_atomic(su_bh->b_page); |
|
su = nilfs_sufile_block_get_segment_usage( |
|
sufile, segnum, su_bh, kaddr); |
|
} |
|
|
|
/* start new extent */ |
|
start = seg_start; |
|
nblocks = seg_end - seg_start + 1; |
|
} |
|
kunmap_atomic(kaddr); |
|
put_bh(su_bh); |
|
} |
|
|
|
|
|
if (nblocks) { |
|
/* discard last extent */ |
|
if (start < start_block) { |
|
nblocks -= start_block - start; |
|
start = start_block; |
|
} |
|
if (start + nblocks > end_block + 1) |
|
nblocks = end_block - start + 1; |
|
|
|
if (nblocks >= minlen) { |
|
ret = blkdev_issue_discard(nilfs->ns_bdev, |
|
start * sects_per_block, |
|
nblocks * sects_per_block, |
|
GFP_NOFS, 0); |
|
if (!ret) |
|
ndiscarded += nblocks; |
|
} |
|
} |
|
|
|
out_sem: |
|
up_read(&NILFS_MDT(sufile)->mi_sem); |
|
|
|
range->len = ndiscarded << nilfs->ns_blocksize_bits; |
|
return ret; |
|
} |
|
|
|
/** |
|
* nilfs_sufile_read - read or get sufile inode |
|
* @sb: super block instance |
|
* @susize: size of a segment usage entry |
|
* @raw_inode: on-disk sufile inode |
|
* @inodep: buffer to store the inode |
|
*/ |
|
int nilfs_sufile_read(struct super_block *sb, size_t susize, |
|
struct nilfs_inode *raw_inode, struct inode **inodep) |
|
{ |
|
struct inode *sufile; |
|
struct nilfs_sufile_info *sui; |
|
struct buffer_head *header_bh; |
|
struct nilfs_sufile_header *header; |
|
void *kaddr; |
|
int err; |
|
|
|
if (susize > sb->s_blocksize) { |
|
nilfs_err(sb, "too large segment usage size: %zu bytes", |
|
susize); |
|
return -EINVAL; |
|
} else if (susize < NILFS_MIN_SEGMENT_USAGE_SIZE) { |
|
nilfs_err(sb, "too small segment usage size: %zu bytes", |
|
susize); |
|
return -EINVAL; |
|
} |
|
|
|
sufile = nilfs_iget_locked(sb, NULL, NILFS_SUFILE_INO); |
|
if (unlikely(!sufile)) |
|
return -ENOMEM; |
|
if (!(sufile->i_state & I_NEW)) |
|
goto out; |
|
|
|
err = nilfs_mdt_init(sufile, NILFS_MDT_GFP, sizeof(*sui)); |
|
if (err) |
|
goto failed; |
|
|
|
nilfs_mdt_set_entry_size(sufile, susize, |
|
sizeof(struct nilfs_sufile_header)); |
|
|
|
err = nilfs_read_inode_common(sufile, raw_inode); |
|
if (err) |
|
goto failed; |
|
|
|
err = nilfs_sufile_get_header_block(sufile, &header_bh); |
|
if (err) |
|
goto failed; |
|
|
|
sui = NILFS_SUI(sufile); |
|
kaddr = kmap_atomic(header_bh->b_page); |
|
header = kaddr + bh_offset(header_bh); |
|
sui->ncleansegs = le64_to_cpu(header->sh_ncleansegs); |
|
kunmap_atomic(kaddr); |
|
brelse(header_bh); |
|
|
|
sui->allocmax = nilfs_sufile_get_nsegments(sufile) - 1; |
|
sui->allocmin = 0; |
|
|
|
unlock_new_inode(sufile); |
|
out: |
|
*inodep = sufile; |
|
return 0; |
|
failed: |
|
iget_failed(sufile); |
|
return err; |
|
}
|
|
|