-496cbe9474173ec41bf221dc8ab1f5d70a128c3b
+d5e561b3cc023dd247d2b3d08b680709ec21b477
extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
struct bio *src, struct bvec_iter *src_iter);
extern void bio_copy_data(struct bio *dst, struct bio *src);
+
+void bio_free_pages(struct bio *bio);
extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);
void complete(struct completion *);
void wait_for_completion(struct completion *);
+#define wait_for_completion_interruptible(x) (wait_for_completion(x), 0)
+
#endif
BUG_ON(getrandom(buf, nbytes, 0) != nbytes);
}
+static inline void prandom_bytes(void *buf, int nbytes)
+{
+ return get_random_bytes(buf, nbytes);
+}
+
#define get_random_type(type) \
static inline type get_random_##type(void) \
{ \
{
}
+static void bch2_sb_print_disk_groups(struct bch_sb *sb, struct bch_sb_field *f,
+ enum units units)
+{
+}
+
typedef void (*sb_field_print_fn)(struct bch_sb *, struct bch_sb_field *, enum units);
struct bch_sb_field_ops {
struct bch_replicas_cpu __rcu *replicas_gc;
struct mutex replicas_gc_lock;
+ struct bch_disk_groups_cpu __rcu *disk_groups;
+
struct bch_opts opts;
/* Updated by bch2_sb_update():*/
x(members, 1) \
x(crypt, 2) \
x(replicas, 3) \
- x(quota, 4)
+ x(quota, 4) \
+ x(disk_groups, 5)
enum bch_sb_field_type {
#define x(f, nr) BCH_SB_FIELD_##f = nr,
LE64_BITMASK(BCH_MEMBER_TIER, struct bch_member, flags[0], 4, 8)
/* 8-10 unused, was HAS_(META)DATA */
LE64_BITMASK(BCH_MEMBER_REPLACEMENT, struct bch_member, flags[0], 10, 14)
-LE64_BITMASK(BCH_MEMBER_DISCARD, struct bch_member, flags[0], 14, 15);
-LE64_BITMASK(BCH_MEMBER_DATA_ALLOWED, struct bch_member, flags[0], 15, 20);
+LE64_BITMASK(BCH_MEMBER_DISCARD, struct bch_member, flags[0], 14, 15)
+LE64_BITMASK(BCH_MEMBER_DATA_ALLOWED, struct bch_member, flags[0], 15, 20)
+LE64_BITMASK(BCH_MEMBER_GROUP, struct bch_member, flags[0], 20, 28)
#if 0
LE64_BITMASK(BCH_MEMBER_NR_READ_ERRORS, struct bch_member, flags[1], 0, 20);
struct bch_sb_quota_type q[QTYP_NR];
} __attribute__((packed, aligned(8)));
+/* BCH_SB_FIELD_disk_groups: */
+
+#define BCH_SB_LABEL_SIZE 32
+
+struct bch_disk_group {
+ __u8 label[BCH_SB_LABEL_SIZE];
+ __le64 flags[2];
+};
+
+LE64_BITMASK(BCH_GROUP_DELETED, struct bch_disk_group, flags[0], 0, 1)
+LE64_BITMASK(BCH_GROUP_DATA_ALLOWED, struct bch_disk_group, flags[0], 1, 6)
+
+struct bch_sb_field_disk_groups {
+ struct bch_sb_field field;
+ struct bch_disk_group entries[0];
+};
+
/* Superblock: */
/*
#define BCH_SB_VERSION_MAX 9
#define BCH_SB_SECTOR 8
-#define BCH_SB_LABEL_SIZE 32
#define BCH_SB_MEMBERS_MAX 64 /* XXX kill */
struct bch_sb_layout {
#define BCH_REPLICAS_MAX 4U
-#if 0
-#define BCH_ERROR_ACTIONS() \
- x(BCH_ON_ERROR_CONTINUE, 0, "continue") \
- x(BCH_ON_ERROR_RO, 1, "remount-ro") \
- x(BCH_ON_ERROR_PANIC, 2, "panic") \
- x(BCH_NR_ERROR_ACTIONS, 3, NULL)
-
-enum bch_error_actions {
-#define x(_opt, _nr, _str) _opt = _nr,
- BCH_ERROR_ACTIONS()
-#undef x
-};
-#endif
-
enum bch_error_actions {
BCH_ON_ERROR_CONTINUE = 0,
BCH_ON_ERROR_RO = 1,
#define BCH_IOCTL_DISK_ONLINE _IOW(0xbc, 6, struct bch_ioctl_disk)
#define BCH_IOCTL_DISK_OFFLINE _IOW(0xbc, 7, struct bch_ioctl_disk)
#define BCH_IOCTL_DISK_SET_STATE _IOW(0xbc, 8, struct bch_ioctl_disk_set_state)
-#define BCH_IOCTL_DISK_EVACUATE _IOW(0xbc, 9, struct bch_ioctl_disk)
#define BCH_IOCTL_DATA _IOW(0xbc, 10, struct bch_ioctl_data)
#define BCH_IOCTL_USAGE _IOWR(0xbc, 11, struct bch_ioctl_usage)
#define BCH_IOCTL_READ_SUPER _IOW(0xbc, 12, struct bch_ioctl_read_super)
__u64 dev;
};
-#define BCH_REWRITE_INCREASE_REPLICAS (1 << 0)
-#define BCH_REWRITE_DECREASE_REPLICAS (1 << 1)
-
-#define BCH_REWRITE_RECOMPRESS (1 << 0)
-#define BCH_REWRITE_DECREASE_REPLICAS (1 << 1)
-
enum bch_data_ops {
- BCH_DATA_SCRUB,
-};
-
-struct bch_data_op {
- __u8 type;
+ BCH_DATA_OP_SCRUB = 0,
+ BCH_DATA_OP_REREPLICATE = 1,
+ BCH_DATA_OP_MIGRATE = 2,
+ BCH_DATA_OP_NR = 3,
};
struct bch_ioctl_data {
+ __u32 op;
__u32 flags;
- __u32 pad;
-
- __u64 start_inode;
- __u64 start_offset;
- __u64 end_inode;
- __u64 end_offset;
-};
+ struct bpos start;
+ struct bpos end;
+
+ union {
+ struct {
+ __u32 dev;
+ __u32 pad;
+ } migrate;
+ };
+} __attribute__((packed, aligned(8)));
+
+struct bch_ioctl_data_progress {
+ __u8 data_type;
+ __u8 btree_id;
+ __u8 pad[2];
+ struct bpos pos;
+
+ __u64 sectors_done;
+ __u64 sectors_total;
+} __attribute__((packed, aligned(8)));
struct bch_ioctl_dev_usage {
__u8 state;
#ifndef NO_BCACHEFS_CHARDEV
#include "bcachefs.h"
+#include "alloc.h"
#include "bcachefs_ioctl.h"
#include "buckets.h"
#include "chardev.h"
+#include "move.h"
#include "super.h"
#include "super-io.h"
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/major.h>
+#include <linux/anon_inodes.h>
#include <linux/cdev.h>
#include <linux/device.h>
+#include <linux/file.h>
+#include <linux/fs.h>
#include <linux/ioctl.h>
-#include <linux/uaccess.h>
+#include <linux/kthread.h>
+#include <linux/major.h>
+#include <linux/sched/task.h>
#include <linux/slab.h>
+#include <linux/uaccess.h>
/* returns with ref on ca->ref */
static struct bch_dev *bch2_device_lookup(struct bch_fs *c, u64 dev,
return ret;
}
-static long bch2_ioctl_disk_evacuate(struct bch_fs *c,
- struct bch_ioctl_disk arg)
+struct bch_data_ctx {
+ struct bch_fs *c;
+ struct bch_ioctl_data arg;
+ struct bch_move_stats stats;
+
+ int ret;
+
+ struct task_struct *thread;
+};
+
+static int bch2_data_thread(void *arg)
{
- struct bch_dev *ca;
- int ret;
+ struct bch_data_ctx *ctx = arg;
- if ((arg.flags & ~BCH_BY_INDEX) ||
- arg.pad)
+ ctx->ret = bch2_data_job(ctx->c, &ctx->stats, ctx->arg);
+
+ ctx->stats.data_type = U8_MAX;
+ return 0;
+}
+
+static int bch2_data_job_release(struct inode *inode, struct file *file)
+{
+ struct bch_data_ctx *ctx = file->private_data;
+
+ kthread_stop(ctx->thread);
+ put_task_struct(ctx->thread);
+ kfree(ctx);
+ return 0;
+}
+
+static ssize_t bch2_data_job_read(struct file *file, char __user *buf,
+ size_t len, loff_t *ppos)
+{
+ struct bch_data_ctx *ctx = file->private_data;
+ struct bch_fs *c = ctx->c;
+ struct bch_ioctl_data_progress p = {
+ .data_type = ctx->stats.data_type,
+ .btree_id = ctx->stats.iter.btree_id,
+ .pos = ctx->stats.iter.pos,
+ .sectors_done = atomic64_read(&ctx->stats.sectors_seen),
+ .sectors_total = bch2_fs_sectors_used(c, bch2_fs_usage_read(c)),
+ };
+
+ if (len != sizeof(p))
return -EINVAL;
- ca = bch2_device_lookup(c, arg.dev, arg.flags);
- if (IS_ERR(ca))
- return PTR_ERR(ca);
+ return copy_to_user(buf, &p, sizeof(p)) ?: sizeof(p);
+}
- ret = bch2_dev_evacuate(c, ca);
+static const struct file_operations bcachefs_data_ops = {
+ .release = bch2_data_job_release,
+ .read = bch2_data_job_read,
+ .llseek = no_llseek,
+};
- percpu_ref_put(&ca->ref);
+static long bch2_ioctl_data(struct bch_fs *c,
+ struct bch_ioctl_data arg)
+{
+ struct bch_data_ctx *ctx = NULL;
+ struct file *file = NULL;
+ unsigned flags = O_RDONLY|O_CLOEXEC|O_NONBLOCK;
+ int ret, fd = -1;
+
+ if (arg.op >= BCH_DATA_OP_NR || arg.flags)
+ return -EINVAL;
+
+ ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+ if (!ctx)
+ return -ENOMEM;
+
+ ctx->c = c;
+ ctx->arg = arg;
+
+ ctx->thread = kthread_create(bch2_data_thread, ctx, "[bcachefs]");
+ if (IS_ERR(ctx->thread)) {
+ ret = PTR_ERR(ctx->thread);
+ goto err;
+ }
+
+ ret = get_unused_fd_flags(flags);
+ if (ret < 0)
+ goto err;
+ fd = ret;
+
+ file = anon_inode_getfile("[bcachefs]", &bcachefs_data_ops, ctx, flags);
+ if (IS_ERR(file)) {
+ ret = PTR_ERR(file);
+ goto err;
+ }
+
+ fd_install(fd, file);
+
+ get_task_struct(ctx->thread);
+ wake_up_process(ctx->thread);
+
+ return fd;
+err:
+ if (fd >= 0)
+ put_unused_fd(fd);
+ if (!IS_ERR_OR_NULL(ctx->thread))
+ kthread_stop(ctx->thread);
+ kfree(ctx);
return ret;
}
BCH_IOCTL(disk_offline, struct bch_ioctl_disk);
case BCH_IOCTL_DISK_SET_STATE:
BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state);
- case BCH_IOCTL_DISK_EVACUATE:
- BCH_IOCTL(disk_evacuate, struct bch_ioctl_disk);
+ case BCH_IOCTL_DATA:
+ BCH_IOCTL(data, struct bch_ioctl_data);
case BCH_IOCTL_READ_SUPER:
BCH_IOCTL(read_super, struct bch_ioctl_read_super);
case BCH_IOCTL_DISK_GET_IDX:
}
}
+static DEFINE_IDR(bch_chardev_minor);
+
static long bch2_chardev_ioctl(struct file *filp, unsigned cmd, unsigned long v)
{
- struct bch_fs *c = filp->private_data;
+ unsigned minor = iminor(file_inode(filp));
+ struct bch_fs *c = minor < U8_MAX ? idr_find(&bch_chardev_minor, minor) : NULL;
void __user *arg = (void __user *) v;
return c
static int bch_chardev_major;
static struct class *bch_chardev_class;
static struct device *bch_chardev;
-static DEFINE_IDR(bch_chardev_minor);
void bch2_fs_chardev_exit(struct bch_fs *c)
{
return c->minor;
c->chardev = device_create(bch_chardev_class, NULL,
- MKDEV(bch_chardev_major, c->minor), NULL,
+ MKDEV(bch_chardev_major, c->minor), c,
"bcachefs%u-ctl", c->minor);
if (IS_ERR(c->chardev))
return PTR_ERR(c->chardev);
{
if (!IS_ERR_OR_NULL(bch_chardev_class))
device_destroy(bch_chardev_class,
- MKDEV(bch_chardev_major, 255));
+ MKDEV(bch_chardev_major, U8_MAX));
if (!IS_ERR_OR_NULL(bch_chardev_class))
class_destroy(bch_chardev_class);
if (bch_chardev_major > 0)
return PTR_ERR(bch_chardev_class);
bch_chardev = device_create(bch_chardev_class, NULL,
- MKDEV(bch_chardev_major, 255),
+ MKDEV(bch_chardev_major, U8_MAX),
NULL, "bcachefs-ctl");
if (IS_ERR(bch_chardev))
return PTR_ERR(bch_chardev);
return dropped;
}
+const struct bch_extent_ptr *
+bch2_extent_has_group(struct bch_fs *c, struct bkey_s_c_extent e, unsigned group)
+{
+ const struct bch_extent_ptr *ptr;
+
+ extent_for_each_ptr(e, ptr) {
+ struct bch_dev *ca = c->devs[ptr->dev];
+
+ if (ca->mi.group &&
+ ca->mi.group == group)
+ return ptr;
+ }
+
+ return NULL;
+}
+
+const struct bch_extent_ptr *
+bch2_extent_has_target(struct bch_fs *c, struct bkey_s_c_extent e, unsigned target)
+{
+ const struct bch_extent_ptr *ptr;
+
+ extent_for_each_ptr(e, ptr)
+ if (dev_in_target(c->devs[ptr->dev], target))
+ return ptr;
+
+ return NULL;
+}
+
unsigned bch2_extent_nr_ptrs(struct bkey_s_c_extent e)
{
const struct bch_extent_ptr *ptr;
const struct bch_extent_ptr *
bch2_extent_has_device(struct bkey_s_c_extent, unsigned);
bool bch2_extent_drop_device(struct bkey_s_extent, unsigned);
+const struct bch_extent_ptr *
+bch2_extent_has_group(struct bch_fs *, struct bkey_s_c_extent, unsigned);
+const struct bch_extent_ptr *
+bch2_extent_has_target(struct bch_fs *, struct bkey_s_c_extent, unsigned);
unsigned bch2_extent_nr_ptrs(struct bkey_s_c_extent);
unsigned bch2_extent_nr_dirty_ptrs(struct bkey_s_c);
return j->pin.front;
}
+static inline u64 journal_cur_seq(struct journal *j)
+{
+ BUG_ON(j->pin.back - 1 != atomic64_read(&j->seq));
+
+ return j->pin.back - 1;
+}
+
static inline u64 journal_pin_seq(struct journal *j,
struct journal_entry_pin_list *pin_list)
{
if (!seq)
return 0;
- journal_seq = atomic64_read(&j->seq);
+ spin_lock(&j->lock);
+ journal_seq = journal_cur_seq(j);
+ spin_unlock(&j->lock);
/* Interier updates aren't journalled: */
BUG_ON(b->level);
u64 cur_seq, end_seq, seq;
unsigned iter, keys = 0, entries = 0;
size_t nr;
+ bool degraded = false;
int ret = 0;
closure_init_stack(&jlist.cl);
jlist.head = list;
jlist.ret = 0;
- for_each_readable_member(ca, c, iter) {
- percpu_ref_get(&ca->io_ref);
- closure_call(&ca->journal.read,
- bch2_journal_read_device,
- system_unbound_wq,
- &jlist.cl);
+ for_each_member_device(ca, c, iter) {
+ if (!(bch2_dev_has_data(c, ca) & (1 << BCH_DATA_JOURNAL)))
+ continue;
+
+ if ((ca->mi.state == BCH_MEMBER_STATE_RW ||
+ ca->mi.state == BCH_MEMBER_STATE_RO) &&
+ percpu_ref_tryget(&ca->io_ref))
+ closure_call(&ca->journal.read,
+ bch2_journal_read_device,
+ system_unbound_wq,
+ &jlist.cl);
+ else
+ degraded = true;
}
closure_sync(&jlist.cl);
if (ret)
goto fsck_err;
- if (test_bit(BCH_FS_REBUILD_REPLICAS, &c->flags) ||
- fsck_err_on(!bch2_sb_has_replicas(c, BCH_DATA_JOURNAL,
- i->devs), c,
- "superblock not marked as containing replicas (type %u)",
- BCH_DATA_JOURNAL)) {
+ /*
+ * If we're mounting in degraded mode - if we didn't read all
+ * the devices - this is wrong:
+ */
+
+ if (!degraded &&
+ (test_bit(BCH_FS_REBUILD_REPLICAS, &c->flags) ||
+ fsck_err_on(!bch2_sb_has_replicas(c, BCH_DATA_JOURNAL,
+ i->devs), c,
+ "superblock not marked as containing replicas (type %u)",
+ BCH_DATA_JOURNAL))) {
ret = bch2_check_mark_super(c, BCH_DATA_JOURNAL,
i->devs);
if (ret)
}
bch_info(c, "journal read done, %i keys in %i entries, seq %llu",
- keys, entries, (u64) atomic64_read(&j->seq));
+ keys, entries, journal_cur_seq(j));
fsck_err:
return ret;
}
atomic64_inc(&j->seq);
p = fifo_push_ref(&j->pin);
- EBUG_ON(journal_seq_pin(j, atomic64_read(&j->seq)) !=
- &fifo_peek_back(&j->pin));
-
INIT_LIST_HEAD(&p->list);
INIT_LIST_HEAD(&p->flushed);
atomic_set(&p->count, count);
memset(buf->has_inode, 0, sizeof(buf->has_inode));
memset(buf->data, 0, sizeof(*buf->data));
- buf->data->seq = cpu_to_le64(atomic64_read(&j->seq));
+ buf->data->seq = cpu_to_le64(journal_cur_seq(j));
buf->data->u64s = 0;
}
set_bit(JOURNAL_STARTED, &j->flags);
- while (atomic64_read(&j->seq) < new_seq)
+ while (journal_cur_seq(j) < new_seq)
journal_pin_new_entry(j, 0);
/*
mutex_unlock(&j->reclaim_lock);
/* Also flush if the pin fifo is more than half full */
+ spin_lock(&j->lock);
seq_to_flush = max_t(s64, seq_to_flush,
- (s64) atomic64_read(&j->seq) -
+ (s64) journal_cur_seq(j) -
(j->pin.size >> 1));
+ spin_unlock(&j->lock);
/*
* If it's been longer than j->reclaim_delay_ms since we last flushed,
ja->sectors_free = ca->mi.bucket_size - sectors;
ja->cur_idx = (ja->cur_idx + 1) % ja->nr;
- ja->bucket_seq[ja->cur_idx] = atomic64_read(&j->seq);
+ ja->bucket_seq[ja->cur_idx] = le64_to_cpu(w->data->seq);
extent_ptr_append(bkey_i_to_extent(&j->key),
(struct bch_extent_ptr) {
spin_lock(&j->lock);
if (test_bit(h, journal_cur_buf(j)->has_inode))
- seq = atomic64_read(&j->seq);
+ seq = journal_cur_seq(j);
else if (test_bit(h, journal_prev_buf(j)->has_inode))
- seq = atomic64_read(&j->seq) - 1;
+ seq = journal_cur_seq(j) - 1;
spin_unlock(&j->lock);
return seq;
u64 seq;
spin_lock(&j->lock);
- seq = atomic64_read(&j->seq);
+ seq = journal_cur_seq(j);
if (j->reservations.prev_buf_unwritten)
seq--;
spin_unlock(&j->lock);
int ret;
spin_lock(&j->lock);
- BUG_ON(seq > atomic64_read(&j->seq));
+ BUG_ON(seq > journal_cur_seq(j));
- if (seq < atomic64_read(&j->seq) ||
+ if (seq < journal_cur_seq(j) ||
journal_entry_is_open(j)) {
spin_unlock(&j->lock);
return 1;
{
spin_lock(&j->lock);
- BUG_ON(seq > atomic64_read(&j->seq));
+ BUG_ON(seq > journal_cur_seq(j));
if (bch2_journal_error(j)) {
spin_unlock(&j->lock);
return;
}
- if (seq == atomic64_read(&j->seq)) {
+ if (seq == journal_cur_seq(j)) {
if (!closure_wait(&journal_cur_buf(j)->wait, parent))
BUG();
- } else if (seq + 1 == atomic64_read(&j->seq) &&
+ } else if (seq + 1 == journal_cur_seq(j) &&
j->reservations.prev_buf_unwritten) {
if (!closure_wait(&journal_prev_buf(j)->wait, parent))
BUG();
spin_lock(&j->lock);
- BUG_ON(seq > atomic64_read(&j->seq));
+ BUG_ON(seq > journal_cur_seq(j));
if (bch2_journal_error(j)) {
spin_unlock(&j->lock);
return;
}
- if (seq == atomic64_read(&j->seq)) {
+ if (seq == journal_cur_seq(j)) {
bool set_need_write = false;
buf = journal_cur_buf(j);
case JOURNAL_ENTRY_CLOSED:
/*
* Journal entry hasn't been opened yet, but caller
- * claims it has something (seq == j->seq):
+ * claims it has something
*/
BUG();
case JOURNAL_ENTRY_INUSE:
return;
}
} else if (parent &&
- seq + 1 == atomic64_read(&j->seq) &&
+ seq + 1 == journal_cur_seq(j) &&
j->reservations.prev_buf_unwritten) {
buf = journal_prev_buf(j);
int ret = 1;
spin_lock(&j->lock);
- BUG_ON(seq > atomic64_read(&j->seq));
+ BUG_ON(seq > journal_cur_seq(j));
- if (seq == atomic64_read(&j->seq)) {
+ if (seq == journal_cur_seq(j)) {
bool set_need_write = false;
ret = 0;
case JOURNAL_ENTRY_CLOSED:
/*
* Journal entry hasn't been opened yet, but caller
- * claims it has something (seq == j->seq):
+ * claims it has something
*/
BUG();
case JOURNAL_ENTRY_INUSE:
case JOURNAL_UNLOCKED:
return 0;
}
- } else if (seq + 1 == atomic64_read(&j->seq) &&
+ } else if (seq + 1 == journal_cur_seq(j) &&
j->reservations.prev_buf_unwritten) {
ret = bch2_journal_error(j);
}
u64 seq, journal_seq;
spin_lock(&j->lock);
- journal_seq = atomic64_read(&j->seq);
+ journal_seq = journal_cur_seq(j);
if (journal_entry_is_open(j)) {
seq = journal_seq;
u64 seq, journal_seq;
spin_lock(&j->lock);
- journal_seq = atomic64_read(&j->seq);
+ journal_seq = journal_cur_seq(j);
if (journal_entry_is_open(j)) {
seq = journal_seq;
return bch2_journal_flush_seq(j, seq);
}
-int bch2_journal_flush_device(struct journal *j, unsigned dev_idx)
+int bch2_journal_flush_device(struct journal *j, int dev_idx)
{
struct bch_fs *c = container_of(j, struct bch_fs, journal);
struct journal_entry_pin_list *p;
spin_lock(&j->lock);
fifo_for_each_entry_ptr(p, &j->pin, iter)
- if (bch2_dev_list_has_dev(p->devs, dev_idx))
+ if (dev_idx >= 0
+ ? bch2_dev_list_has_dev(p->devs, dev_idx)
+ : p->devs.nr < c->opts.metadata_replicas)
seq = iter;
spin_unlock(&j->lock);
seq = 0;
spin_lock(&j->lock);
- while (!ret && seq < atomic64_read(&j->seq)) {
+ while (!ret && seq < j->pin.back) {
seq = max(seq, journal_last_seq(j));
devs = journal_seq_pin(j, seq)->devs;
seq++;
"dirty:\t\t\t%i\n"
"replay done:\t\t%i\n",
fifo_used(&j->pin),
- (u64) atomic64_read(&j->seq),
+ journal_cur_seq(j),
journal_last_seq(j),
j->last_seq_ondisk,
journal_state_count(*s, s->idx),
int bch2_journal_flush_seq(struct journal *, u64);
int bch2_journal_flush(struct journal *);
int bch2_journal_meta(struct journal *);
-int bch2_journal_flush_device(struct journal *, unsigned);
+int bch2_journal_flush_device(struct journal *, int);
void bch2_journal_halt(struct journal *);
* operations
*/
do {
+ memset(&stats, 0, sizeof(stats));
+
ret = bch2_move_data(c, NULL,
SECTORS_IN_FLIGHT_PER_DEVICE,
NULL,
writepoint_hashed((unsigned long) current),
0,
ca->dev_idx,
+ POS_MIN, POS_MAX,
migrate_pred, ca,
&stats);
if (ret) {
m->move_dev)))
bch2_extent_drop_ptr(extent_i_to_s(insert), ptr);
-
extent_for_each_ptr_crc(extent_i_to_s(new), ptr, crc) {
if (bch2_extent_has_device(extent_i_to_s_c(insert), ptr->dev)) {
/*
struct bio_vec *bv;
int i;
+ bch2_disk_reservation_put(io->write.op.c, &io->write.op.res);
+
bio_for_each_segment_all(bv, &io->write.op.wbio.bio, i)
if (bv->bv_page)
__free_page(bv->bv_page);
int btree_insert_flags,
int move_device,
struct bch_io_opts opts,
- struct bkey_s_c k)
+ struct bkey_s_c_extent e)
{
struct extent_pick_ptr pick;
struct moving_io *io;
const struct bch_extent_ptr *ptr;
struct bch_extent_crc_unpacked crc;
- unsigned sectors = k.k->size, pages;
+ unsigned sectors = e.k->size, pages, nr_good;
+ int ret = -ENOMEM;
- bch2_extent_pick_ptr(c, k, NULL, &pick);
+ bch2_extent_pick_ptr(c, e.s_c, NULL, &pick);
if (IS_ERR_OR_NULL(pick.ca))
return pick.ca ? PTR_ERR(pick.ca) : 0;
/* write path might have to decompress data: */
- extent_for_each_ptr_crc(bkey_s_c_to_extent(k), ptr, crc)
+ extent_for_each_ptr_crc(e, ptr, crc)
sectors = max_t(unsigned, sectors, crc.uncompressed_size);
pages = DIV_ROUND_UP(sectors, PAGE_SECTORS);
goto err;
io->write.ctxt = ctxt;
- io->sectors = k.k->size;
+ io->sectors = e.k->size;
bio_init(&io->write.op.wbio.bio, io->bi_inline_vecs, pages);
bio_set_prio(&io->write.op.wbio.bio,
io->write.op.wbio.bio.bi_iter.bi_size = sectors << 9;
bch2_bio_map(&io->write.op.wbio.bio, NULL);
- if (bio_alloc_pages(&io->write.op.wbio.bio, GFP_KERNEL)) {
- kfree(io);
- goto err;
- }
+ if (bio_alloc_pages(&io->write.op.wbio.bio, GFP_KERNEL))
+ goto err_free;
io->rbio.opts = opts;
bio_init(&io->rbio.bio, io->bi_inline_vecs, pages);
io->rbio.bio.bi_iter.bi_size = sectors << 9;
bio_set_op_attrs(&io->rbio.bio, REQ_OP_READ, 0);
- io->rbio.bio.bi_iter.bi_sector = bkey_start_offset(k.k);
+ io->rbio.bio.bi_iter.bi_sector = bkey_start_offset(e.k);
io->rbio.bio.bi_end_io = move_read_endio;
io->write.btree_insert_flags = btree_insert_flags;
io->write.op.devs = devs;
io->write.op.write_point = wp;
+ if (move_device < 0 &&
+ ((nr_good = bch2_extent_nr_good_ptrs(c, e)) <
+ c->opts.data_replicas)) {
+ io->write.op.nr_replicas = c->opts.data_replicas - nr_good;
+
+ ret = bch2_disk_reservation_get(c, &io->write.op.res,
+ e.k->size,
+ io->write.op.nr_replicas, 0);
+ if (ret)
+ goto err_free_pages;
+ }
+
atomic64_inc(&ctxt->stats->keys_moved);
- atomic64_add(k.k->size, &ctxt->stats->sectors_moved);
+ atomic64_add(e.k->size, &ctxt->stats->sectors_moved);
- trace_move_extent(k.k);
+ trace_move_extent(e.k);
atomic_add(io->sectors, &ctxt->sectors_in_flight);
list_add_tail(&io->list, &ctxt->reads);
* ctxt when doing wakeup
*/
closure_get(&ctxt->cl);
- bch2_read_extent(c, &io->rbio, bkey_s_c_to_extent(k),
- &pick, BCH_READ_NODECODE);
+ bch2_read_extent(c, &io->rbio, e, &pick, BCH_READ_NODECODE);
return 0;
+err_free_pages:
+ bio_free_pages(&io->write.op.wbio.bio);
+err_free:
+ kfree(io);
err:
- trace_move_alloc_fail(k.k);
- return -ENOMEM;
+ percpu_ref_put(&pick.ca->io_ref);
+ trace_move_alloc_fail(e.k);
+ return ret;
}
static void do_pending_writes(struct moving_context *ctxt)
struct write_point_specifier wp,
int btree_insert_flags,
int move_device,
+ struct bpos start,
+ struct bpos end,
move_pred_fn pred, void *arg,
struct bch_move_stats *stats)
{
struct bch_io_opts opts = bch2_opts_to_inode_opts(c->opts);
BKEY_PADDED(k) tmp;
struct bkey_s_c k;
+ struct bkey_s_c_extent e;
u64 cur_inum = U64_MAX;
int ret = 0;
- memset(stats, 0, sizeof(*stats));
closure_init_stack(&ctxt.cl);
INIT_LIST_HEAD(&ctxt.reads);
init_waitqueue_head(&ctxt.wait);
- bch2_btree_iter_init(&stats->iter, c, BTREE_ID_EXTENTS, POS_MIN,
+
+ stats->data_type = BCH_DATA_USER;
+ bch2_btree_iter_init(&stats->iter, c, BTREE_ID_EXTENTS, start,
BTREE_ITER_PREFETCH);
if (rate)
ret = btree_iter_err(k);
if (ret)
break;
+ if (bkey_cmp(bkey_start_pos(k.k), end) >= 0)
+ break;
if (!bkey_extent_is_data(k.k))
goto next_nondata;
+ e = bkey_s_c_to_extent(k);
+
if (cur_inum != k.k->p.inode) {
struct bch_inode_unpacked inode;
goto peek;
}
- if (!pred(arg, bkey_s_c_to_extent(k)))
+ if (!pred(arg, e))
goto next;
/* unlock before doing IO: */
if (bch2_move_extent(c, &ctxt, devs, wp,
btree_insert_flags,
- move_device, opts, k)) {
+ move_device, opts,
+ bkey_s_c_to_extent(k))) {
/* memory allocation failure, wait for some IO to finish */
bch2_move_ctxt_wait_for_io(&ctxt);
continue;
return ret;
}
+
+static int bch2_gc_data_replicas(struct bch_fs *c)
+{
+ struct btree_iter iter;
+ struct bkey_s_c k;
+ int ret;
+
+ mutex_lock(&c->replicas_gc_lock);
+ bch2_replicas_gc_start(c, 1 << BCH_DATA_USER);
+
+ for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS_MIN,
+ BTREE_ITER_PREFETCH, k) {
+ ret = bch2_check_mark_super(c, BCH_DATA_USER, bch2_bkey_devs(k));
+ if (ret)
+ break;
+ }
+ ret = bch2_btree_iter_unlock(&iter) ?: ret;
+
+ bch2_replicas_gc_end(c, ret);
+ mutex_unlock(&c->replicas_gc_lock);
+
+ return ret;
+}
+
+static int bch2_gc_btree_replicas(struct bch_fs *c)
+{
+ struct btree_iter iter;
+ struct btree *b;
+ unsigned id;
+ int ret = 0;
+
+ mutex_lock(&c->replicas_gc_lock);
+ bch2_replicas_gc_start(c, 1 << BCH_DATA_BTREE);
+
+ for (id = 0; id < BTREE_ID_NR; id++) {
+ for_each_btree_node(&iter, c, id, POS_MIN, BTREE_ITER_PREFETCH, b) {
+ ret = bch2_check_mark_super(c, BCH_DATA_BTREE,
+ bch2_bkey_devs(bkey_i_to_s_c(&b->key)));
+
+ bch2_btree_iter_cond_resched(&iter);
+ }
+
+ ret = bch2_btree_iter_unlock(&iter) ?: ret;
+ }
+
+ bch2_replicas_gc_end(c, ret);
+ mutex_unlock(&c->replicas_gc_lock);
+
+ return ret;
+}
+
+static int bch2_move_btree(struct bch_fs *c,
+ move_pred_fn pred,
+ void *arg,
+ struct bch_move_stats *stats)
+{
+ struct btree *b;
+ unsigned id;
+ int ret = 0;
+
+ stats->data_type = BCH_DATA_BTREE;
+
+ for (id = 0; id < BTREE_ID_NR; id++) {
+ for_each_btree_node(&stats->iter, c, id, POS_MIN, BTREE_ITER_PREFETCH, b) {
+ if (pred(arg, bkey_i_to_s_c_extent(&b->key)))
+ ret = bch2_btree_node_rewrite(c, &stats->iter,
+ b->data->keys.seq, 0) ?: ret;
+
+ bch2_btree_iter_cond_resched(&stats->iter);
+ }
+
+ ret = bch2_btree_iter_unlock(&stats->iter) ?: ret;
+ }
+
+ return ret;
+}
+
+#if 0
+static bool scrub_data_pred(void *arg, struct bkey_s_c_extent e)
+{
+}
+#endif
+
+static bool rereplicate_metadata_pred(void *arg, struct bkey_s_c_extent e)
+{
+ struct bch_fs *c = arg;
+ unsigned nr_good = bch2_extent_nr_good_ptrs(c, e);
+
+ return nr_good && nr_good < c->opts.metadata_replicas;
+}
+
+static bool rereplicate_data_pred(void *arg, struct bkey_s_c_extent e)
+{
+ struct bch_fs *c = arg;
+ unsigned nr_good = bch2_extent_nr_good_ptrs(c, e);
+
+ return nr_good && nr_good < c->opts.data_replicas;
+}
+
+static bool migrate_pred(void *arg, struct bkey_s_c_extent e)
+{
+ struct bch_ioctl_data *op = arg;
+
+ return bch2_extent_has_device(e, op->migrate.dev);
+}
+
+int bch2_data_job(struct bch_fs *c,
+ struct bch_move_stats *stats,
+ struct bch_ioctl_data op)
+{
+ int ret = 0;
+
+ switch (op.op) {
+ case BCH_DATA_OP_REREPLICATE:
+ stats->data_type = BCH_DATA_JOURNAL;
+ ret = bch2_journal_flush_device(&c->journal, -1);
+
+ ret = bch2_move_btree(c, rereplicate_metadata_pred, c, stats) ?: ret;
+ ret = bch2_gc_btree_replicas(c) ?: ret;
+
+ ret = bch2_move_data(c, NULL, SECTORS_IN_FLIGHT_PER_DEVICE,
+ NULL,
+ writepoint_hashed((unsigned long) current),
+ 0, -1,
+ op.start,
+ op.end,
+ rereplicate_data_pred, c, stats) ?: ret;
+ ret = bch2_gc_data_replicas(c) ?: ret;
+ break;
+ case BCH_DATA_OP_MIGRATE:
+ if (op.migrate.dev >= c->sb.nr_devices)
+ return -EINVAL;
+
+ stats->data_type = BCH_DATA_JOURNAL;
+ ret = bch2_journal_flush_device(&c->journal, op.migrate.dev);
+
+ ret = bch2_move_btree(c, migrate_pred, &op, stats) ?: ret;
+ ret = bch2_gc_btree_replicas(c) ?: ret;
+
+ ret = bch2_move_data(c, NULL, SECTORS_IN_FLIGHT_PER_DEVICE,
+ NULL,
+ writepoint_hashed((unsigned long) current),
+ 0, -1,
+ op.start,
+ op.end,
+ migrate_pred, &op, stats) ?: ret;
+ ret = bch2_gc_data_replicas(c) ?: ret;
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
typedef bool (*move_pred_fn)(void *, struct bkey_s_c_extent);
struct bch_move_stats {
+ enum bch_data_type data_type;
struct btree_iter iter;
atomic64_t keys_moved;
int bch2_move_data(struct bch_fs *, struct bch_ratelimit *,
unsigned, struct bch_devs_mask *,
struct write_point_specifier,
- int, int, move_pred_fn, void *,
+ int, int, struct bpos, struct bpos,
+ move_pred_fn, void *,
struct bch_move_stats *);
+int bch2_data_job(struct bch_fs *,
+ struct bch_move_stats *,
+ struct bch_ioctl_data);
+
#endif /* _BCACHEFS_MOVE_H */
size_t b;
int ret;
+ memset(&move_stats, 0, sizeof(move_stats));
closure_wait_event(&c->freelist_wait, have_copygc_reserve(ca));
/*
writepoint_ptr(&ca->copygc_write_point),
BTREE_INSERT_USE_RESERVE,
ca->dev_idx,
+ POS_MIN, POS_MAX,
copygc_pred, ca,
&move_stats);
static int bch2_sb_replicas_to_cpu_replicas(struct bch_fs *);
static int bch2_cpu_replicas_to_sb_replicas(struct bch_fs *,
struct bch_replicas_cpu *);
+static int bch2_sb_disk_groups_to_cpu(struct bch_fs *);
/* superblock fields (optional/variable size sections: */
static const char *bch2_sb_field_validate(struct bch_sb *sb,
struct bch_sb_field *f)
+
{
unsigned type = le32_to_cpu(f->type);
if (!sb->nr_devices ||
sb->nr_devices <= sb->dev_idx ||
sb->nr_devices > BCH_SB_MEMBERS_MAX)
- return "Bad cache device number in set";
+ return "Bad number of member devices";
if (!BCH_SB_META_REPLICAS_WANT(sb) ||
BCH_SB_META_REPLICAS_WANT(sb) >= BCH_REPLICAS_MAX)
if (ret)
return ret;
+ ret = bch2_sb_disk_groups_to_cpu(c);
+ if (ret)
+ return ret;
+
bch2_sb_update(c);
return 0;
}
return NULL;
}
+
+/* Disk groups: */
+
+#if 0
+static size_t trim_nulls(const char *str, size_t len)
+{
+ while (len && !str[len - 1])
+ --len;
+ return len;
+}
+#endif
+
+static const char *bch2_sb_validate_disk_groups(struct bch_sb *sb,
+ struct bch_sb_field *f)
+{
+ struct bch_sb_field_disk_groups *groups =
+ field_to_type(f, disk_groups);
+ struct bch_sb_field_members *mi;
+ struct bch_member *m;
+ struct bch_disk_group *g;
+ unsigned nr_groups;
+
+ mi = bch2_sb_get_members(sb);
+ groups = bch2_sb_get_disk_groups(sb);
+ nr_groups = disk_groups_nr(groups);
+
+ for (m = mi->members;
+ m < mi->members + sb->nr_devices;
+ m++) {
+ if (!BCH_MEMBER_GROUP(m))
+ continue;
+
+ if (BCH_MEMBER_GROUP(m) >= nr_groups)
+ return "disk has invalid group";
+
+ g = &groups->entries[BCH_MEMBER_GROUP(m)];
+ if (BCH_GROUP_DELETED(g))
+ return "disk has invalid group";
+ }
+#if 0
+ if (!groups)
+ return NULL;
+
+ char **labels;
+ labels = kcalloc(nr_groups, sizeof(char *), GFP_KERNEL);
+ if (!labels)
+ return "cannot allocate memory";
+
+ for (g = groups->groups;
+ g < groups->groups + nr_groups;
+ g++) {
+
+ }
+#endif
+ return NULL;
+}
+
+static int bch2_sb_disk_groups_to_cpu(struct bch_fs *c)
+{
+ struct bch_sb_field_members *mi;
+ struct bch_sb_field_disk_groups *groups;
+ struct bch_disk_groups_cpu *cpu_g, *old_g;
+ unsigned i, nr_groups;
+
+ lockdep_assert_held(&c->sb_lock);
+
+ mi = bch2_sb_get_members(c->disk_sb);
+ groups = bch2_sb_get_disk_groups(c->disk_sb);
+ nr_groups = disk_groups_nr(groups);
+
+ if (!groups)
+ return 0;
+
+ cpu_g = kzalloc(sizeof(*cpu_g) +
+ sizeof(cpu_g->entries[0]) * nr_groups, GFP_KERNEL);
+ if (!cpu_g)
+ return -ENOMEM;
+
+ cpu_g->nr = nr_groups;
+
+ for (i = 0; i < nr_groups; i++) {
+ struct bch_disk_group *src = &groups->entries[i];
+ struct bch_disk_group_cpu *dst = &cpu_g->entries[i];
+
+ dst->deleted = BCH_GROUP_DELETED(src);
+ }
+
+ for (i = 0; i < c->disk_sb->nr_devices; i++) {
+ struct bch_member *m = mi->members + i;
+ struct bch_disk_group_cpu *dst =
+ &cpu_g->entries[BCH_MEMBER_GROUP(m)];
+
+ if (!bch2_member_exists(m))
+ continue;
+
+ __set_bit(i, dst->devs.d);
+ }
+
+ old_g = c->disk_groups;
+ rcu_assign_pointer(c->disk_groups, cpu_g);
+ if (old_g)
+ kfree_rcu(old_g, rcu);
+
+ return 0;
+}
+
+const struct bch_devs_mask *bch2_target_to_mask(struct bch_fs *c, unsigned target)
+{
+ struct target t = target_decode(target);
+
+ switch (t.type) {
+ case TARGET_DEV:
+ BUG_ON(t.dev >= c->sb.nr_devices && !c->devs[t.dev]);
+ return &c->devs[t.dev]->self;
+ case TARGET_GROUP: {
+ struct bch_disk_groups_cpu *g =
+ rcu_dereference(c->disk_groups);
+
+ /* XXX: what to do here? */
+ BUG_ON(t.group >= g->nr || g->entries[t.group].deleted);
+ return &g->entries[t.group].devs;
+ }
+ default:
+ BUG();
+ }
+}
.nbuckets = le64_to_cpu(mi->nbuckets),
.first_bucket = le16_to_cpu(mi->first_bucket),
.bucket_size = le16_to_cpu(mi->bucket_size),
+ .group = BCH_MEMBER_GROUP(mi),
.state = BCH_MEMBER_STATE(mi),
.tier = BCH_MEMBER_TIER(mi),
.replacement = BCH_MEMBER_REPLACEMENT(mi),
(void *) (_i) < vstruct_end(&(_r)->field) && (_i)->data_type;\
(_i) = replicas_entry_next(_i))
+/* disk groups: */
+
+static inline unsigned disk_groups_nr(struct bch_sb_field_disk_groups *groups)
+{
+ return groups
+ ? (vstruct_end(&groups->field) -
+ (void *) &groups->entries[0]) / sizeof(struct bch_disk_group)
+ : 0;
+}
+
+struct target {
+ enum {
+ TARGET_NULL,
+ TARGET_DEV,
+ TARGET_GROUP,
+ } type;
+ union {
+ unsigned dev;
+ unsigned group;
+ };
+};
+
+static inline u16 dev_to_target(unsigned dev)
+{
+ return 1 + dev;
+}
+
+static inline u16 group_to_target(unsigned group)
+{
+ return 1 + U8_MAX + group;
+}
+
+static inline struct target target_decode(unsigned target)
+{
+ if (!target)
+ return (struct target) { .type = TARGET_NULL };
+
+ --target;
+ if (target <= U8_MAX)
+ return (struct target) { .type = TARGET_DEV, .dev = target };
+
+ target -= U8_MAX;
+ return (struct target) { .type = TARGET_GROUP, .group = target };
+}
+
+static inline bool dev_in_target(struct bch_dev *ca, unsigned target)
+{
+ struct target t = target_decode(target);
+
+ switch (t.type) {
+ case TARGET_DEV:
+ return ca->dev_idx == t.dev;
+ case TARGET_GROUP:
+ return ca->mi.group && ca->mi.group == t.group;
+ default:
+ BUG();
+ }
+}
+
+const struct bch_devs_mask *bch2_target_to_mask(struct bch_fs *, unsigned);
+
#endif /* _BCACHEFS_SUPER_IO_H */
mempool_exit(&c->fill_iter);
percpu_ref_exit(&c->writes);
kfree(rcu_dereference_protected(c->replicas, 1));
+ kfree(rcu_dereference_protected(c->disk_groups, 1));
if (c->copygc_wq)
destroy_workqueue(c->copygc_wq);
BUG_ON(!percpu_ref_is_zero(&ca->io_ref));
+ if (get_capacity(sb->bdev->bd_disk) <
+ ca->mi.bucket_size * ca->mi.nbuckets) {
+ bch_err(c, "device too small");
+ return -EINVAL;
+ }
+
ret = bch2_dev_journal_init(ca, sb->sb);
if (ret)
return ret;
mutex_lock(&c->state_lock);
mutex_lock(&c->sb_lock);
- /*
- * Preserve the old cache member information (esp. tier)
- * before we start bashing the disk stuff.
- */
+ /* Grab member info for new disk: */
dev_mi = bch2_sb_get_members(sb.sb);
saved_mi = dev_mi->members[sb.sb->dev_idx];
saved_mi.last_mount = cpu_to_le64(ktime_get_seconds());
return 0;
}
-int bch2_dev_evacuate(struct bch_fs *c, struct bch_dev *ca)
-{
- unsigned data;
- int ret = 0;
-
- mutex_lock(&c->state_lock);
-
- if (ca->mi.state == BCH_MEMBER_STATE_RW &&
- bch2_dev_is_online(ca)) {
- bch_err(ca, "Cannot migrate data off RW device");
- ret = -EINVAL;
- goto err;
- }
-
- ret = bch2_dev_data_migrate(c, ca, 0);
- if (ret) {
- bch_err(ca, "Error migrating data: %i", ret);
- goto err;
- }
-
- ret = bch2_journal_flush_device(&c->journal, ca->dev_idx);
- if (ret) {
- bch_err(ca, "Migrate failed: error %i flushing journal", ret);
- goto err;
- }
-
- data = bch2_dev_has_data(c, ca);
- if (data) {
- char buf[100];
-
- bch2_scnprint_flag_list(buf, sizeof(buf),
- bch2_data_types, data);
- bch_err(ca, "Migrate failed, still has data (%s)", buf);
- ret = -EINVAL;
- goto err;
- }
-err:
- mutex_unlock(&c->state_lock);
- return ret;
-}
-
int bch2_dev_resize(struct bch_fs *c, struct bch_dev *ca, u64 nbuckets)
{
struct bch_member *mi;
return ca->disk_sb.bdev != NULL;
}
-static inline unsigned dev_mask_nr(struct bch_devs_mask *devs)
+static inline unsigned dev_mask_nr(const struct bch_devs_mask *devs)
{
return bitmap_weight(devs->d, BCH_SB_MEMBERS_MAX);
}
}
static inline struct bch_dev *__bch2_next_dev(struct bch_fs *c, unsigned *iter,
- struct bch_devs_mask *mask)
+ const struct bch_devs_mask *mask)
{
struct bch_dev *ca = NULL;
int bch2_dev_add(struct bch_fs *, const char *);
int bch2_dev_online(struct bch_fs *, const char *);
int bch2_dev_offline(struct bch_fs *, struct bch_dev *, int);
-int bch2_dev_evacuate(struct bch_fs *, struct bch_dev *);
int bch2_dev_resize(struct bch_fs *, struct bch_dev *, u64);
bool bch2_fs_emergency_read_only(struct bch_fs *);
u64 nbuckets; /* device size */
u16 first_bucket; /* index of first bucket used */
u16 bucket_size; /* sectors */
+ u16 group;
u8 state;
u8 tier;
u8 replacement;
struct bch_replicas_cpu_entry entries[];
};
+struct bch_disk_group_cpu {
+ struct bch_devs_mask devs;
+ bool deleted;
+};
+
+struct bch_disk_groups_cpu {
+ struct rcu_head rcu;
+ unsigned nr;
+ struct bch_disk_group_cpu entries[];
+};
+
#endif /* _BCACHEFS_SUPER_TYPES_H */
unsigned long last;
unsigned i, nr_devices;
+ memset(&move_stats, 0, sizeof(move_stats));
set_freezable();
while (!kthread_should_stop()) {
writepoint_ptr(&tier->wp),
0,
-1,
+ POS_MIN, POS_MAX,
tiering_pred, tier,
&move_stats);
}
return split;
}
+void bio_free_pages(struct bio *bio)
+{
+ struct bio_vec *bvec;
+ int i;
+
+ bio_for_each_segment_all(bvec, bio, i)
+ __free_page(bvec->bv_page);
+}
+
int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
{
int i;
projects / bcachefs-tools-debian / commitdiff