path: root/fs/bcachefs/fs.c

// SPDX-License-Identifier: GPL-2.0
#ifndef NO_BCACHEFS_FS

#include "bcachefs.h"
#include "acl.h"
#include "bkey_on_stack.h"
#include "btree_update.h"
#include "buckets.h"
#include "chardev.h"
#include "dirent.h"
#include "extents.h"
#include "fs.h"
#include "fs-common.h"
#include "fs-io.h"
#include "fs-ioctl.h"
#include "fsck.h"
#include "inode.h"
#include "io.h"
#include "journal.h"
#include "keylist.h"
#include "quota.h"
#include "super.h"
#include "xattr.h"

#include <linux/aio.h>
#include <linux/backing-dev.h>
#include <linux/exportfs.h>
#include <linux/fiemap.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/posix_acl.h>
#include <linux/random.h>
#include <linux/seq_file.h>
#include <linux/statfs.h>
#include <linux/xattr.h>

static struct kmem_cache *bch2_inode_cache;

static void bch2_vfs_inode_init(struct bch_fs *,
				struct bch_inode_info *,
				struct bch_inode_unpacked *);

static void journal_seq_copy(struct bch_inode_info *dst,
			     u64 journal_seq)
{
	u64 old, v = READ_ONCE(dst->ei_journal_seq);

	do {
		old = v;

		if (old >= journal_seq)
			break;
	} while ((v = cmpxchg(&dst->ei_journal_seq, old, journal_seq)) != old);
}

static void __pagecache_lock_put(struct pagecache_lock *lock, long i)
{
	BUG_ON(atomic_long_read(&lock->v) == 0);

	if (atomic_long_sub_return_release(i, &lock->v) == 0)
		wake_up_all(&lock->wait);
}

static bool __pagecache_lock_tryget(struct pagecache_lock *lock, long i)
{
	long v = atomic_long_read(&lock->v), old;

	do {
		old = v;

		if (i > 0 ? v < 0 : v > 0)
			return false;
	} while ((v = atomic_long_cmpxchg_acquire(&lock->v,
					old, old + i)) != old);
	return true;
}

static void __pagecache_lock_get(struct pagecache_lock *lock, long i)
{
	wait_event(lock->wait, __pagecache_lock_tryget(lock, i));
}

void bch2_pagecache_add_put(struct pagecache_lock *lock)
{
	__pagecache_lock_put(lock, 1);
}

void bch2_pagecache_add_get(struct pagecache_lock *lock)
{
	__pagecache_lock_get(lock, 1);
}

void bch2_pagecache_block_put(struct pagecache_lock *lock)
{
	__pagecache_lock_put(lock, -1);
}

void bch2_pagecache_block_get(struct pagecache_lock *lock)
{
	__pagecache_lock_get(lock, -1);
}

void bch2_inode_update_after_write(struct bch_fs *c,
				   struct bch_inode_info *inode,
				   struct bch_inode_unpacked *bi,
				   unsigned fields)
{
	set_nlink(&inode->v, bch2_inode_nlink_get(bi));
	i_uid_write(&inode->v, bi->bi_uid);
	i_gid_write(&inode->v, bi->bi_gid);
	inode->v.i_mode	= bi->bi_mode;

	if (fields & ATTR_ATIME)
		inode->v.i_atime = bch2_time_to_timespec(c, bi->bi_atime);
	if (fields & ATTR_MTIME)
		inode->v.i_mtime = bch2_time_to_timespec(c, bi->bi_mtime);
	if (fields & ATTR_CTIME)
		inode_set_ctime_to_ts(&inode->v, bch2_time_to_timespec(c, bi->bi_ctime));

	inode->ei_inode		= *bi;

	bch2_inode_flags_to_vfs(inode);
}

int __must_check bch2_write_inode(struct bch_fs *c,
				  struct bch_inode_info *inode,
				  inode_set_fn set,
				  void *p, unsigned fields)
{
	struct btree_trans trans;
	struct btree_iter *iter;
	struct bch_inode_unpacked inode_u;
	int ret;

	bch2_trans_init(&trans, c, 0, 0);
retry:
	bch2_trans_begin(&trans);

	iter = bch2_inode_peek(&trans, &inode_u, inode->v.i_ino,
			       BTREE_ITER_INTENT);
	ret   = PTR_ERR_OR_ZERO(iter) ?:
		(set ? set(inode, &inode_u, p) : 0) ?:
		bch2_inode_write(&trans, iter, &inode_u) ?:
		bch2_trans_commit(&trans, NULL,
				  &inode->ei_journal_seq,
				  BTREE_INSERT_NOUNLOCK|
				  BTREE_INSERT_NOFAIL);

	/*
	 * the btree node lock protects inode->ei_inode, not ei_update_lock;
	 * this is important for inode updates via bchfs_write_index_update
	 */
	if (!ret)
		bch2_inode_update_after_write(c, inode, &inode_u, fields);