Release 4.10 fs/gfs2/sys.c

Directory: fs/gfs2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/module.h>
#include <linux/kobject.h>
#include <linux/uaccess.h>
#include <linux/gfs2_ondisk.h>
#include <linux/genhd.h>

#include "gfs2.h"
#include "incore.h"
#include "sys.h"
#include "super.h"
#include "glock.h"
#include "quota.h"
#include "util.h"
#include "glops.h"
#include "recovery.h"


struct gfs2_attr {
	
struct attribute attr;
	
ssize_t (*show)(struct gfs2_sbd *, char *);
	
ssize_t (*store)(struct gfs2_sbd *, const char *, size_t);
};



static ssize_t gfs2_attr_show(struct kobject *kobj, struct attribute *attr,
			      char *buf)
{
	struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
	struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
	return a->show ? a->show(sdp, buf) : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 66 100.00% 1 100.00%
Total 66 100.00% 1 100.00%



static ssize_t gfs2_attr_store(struct kobject *kobj, struct attribute *attr,
			       const char *buf, size_t len)
{
	struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
	struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
	return a->store ? a->store(sdp, buf, len) : len;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%


static const struct sysfs_ops gfs2_attr_ops = {
	.show  = gfs2_attr_show,
	.store = gfs2_attr_store,
};



static struct kset *gfs2_kset;



static ssize_t id_show(struct gfs2_sbd *sdp, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%u:%u\n",
			MAJOR(sdp->sd_vfs->s_dev), MINOR(sdp->sd_vfs->s_dev));
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 33 76.74% 2 66.67%
robert s. peterson robert s. peterson 10 23.26% 1 33.33%
Total 43 100.00% 3 100.00%



static ssize_t fsname_show(struct gfs2_sbd *sdp, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s\n", sdp->sd_fsname);
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 29 100.00% 2 100.00%
Total 29 100.00% 2 100.00%



static int gfs2_uuid_valid(const u8 *uuid)
{
	int i;

	for (i = 0; i < 16; i++) {
		if (uuid[i])
			return 1;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%



static ssize_t uuid_show(struct gfs2_sbd *sdp, char *buf)
{
	struct super_block *s = sdp->sd_vfs;
	const u8 *uuid = s->s_uuid;
	buf[0] = '\0';
	if (!gfs2_uuid_valid(uuid))
		return 0;
	return snprintf(buf, PAGE_SIZE, "%pUB\n", uuid);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 62 98.41% 2 66.67%
joe perches joe perches 1 1.59% 1 33.33%
Total 63 100.00% 3 100.00%



static ssize_t freeze_show(struct gfs2_sbd *sdp, char *buf)
{
	struct super_block *sb = sdp->sd_vfs;
	int frozen = (sb->s_writers.frozen == SB_UNFROZEN) ? 0 : 1;

	return snprintf(buf, PAGE_SIZE, "%d\n", frozen);
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 28 52.83% 2 50.00%
steven whitehouse steven whitehouse 24 45.28% 1 25.00%
alex chen alex chen 1 1.89% 1 25.00%
Total 53 100.00% 4 100.00%



static ssize_t freeze_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	int error, n;

	error = kstrtoint(buf, 0, &n);
	if (error)
		return error;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	switch (n) {
	case 0:
		error = thaw_super(sdp->sd_vfs);
		break;
	case 1:
		error = freeze_super(sdp->sd_vfs);
		break;
	default:
		return -EINVAL;
	}

	if (error) {
		fs_warn(sdp, "freeze %d error %d", n, error);
		return error;
	}

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 82 71.30% 1 25.00%
steven whitehouse steven whitehouse 16 13.91% 1 25.00%
fabian frederick fabian frederick 16 13.91% 1 25.00%
zhao hongjiang zhao hongjiang 1 0.87% 1 25.00%
Total 115 100.00% 4 100.00%



static ssize_t withdraw_show(struct gfs2_sbd *sdp, char *buf)
{
	unsigned int b = test_bit(SDF_SHUTDOWN, &sdp->sd_flags);
	return snprintf(buf, PAGE_SIZE, "%u\n", b);
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 41 100.00% 2 100.00%
Total 41 100.00% 2 100.00%



static ssize_t withdraw_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	int error, val;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	error = kstrtoint(buf, 0, &val);
	if (error)
		return error;

	if (val != 1)
		return -EINVAL;

	gfs2_lm_withdraw(sdp, "withdrawing from cluster at user's request\n");

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 51 68.00% 1 25.00%
fabian frederick fabian frederick 22 29.33% 1 25.00%
joe perches joe perches 1 1.33% 1 25.00%
zhao hongjiang zhao hongjiang 1 1.33% 1 25.00%
Total 75 100.00% 4 100.00%



static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,
				 size_t len)
{
	int error, val;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	error = kstrtoint(buf, 0, &val);
	if (error)
		return error;

	if (val != 1)
		return -EINVAL;

	gfs2_statfs_sync(sdp->sd_vfs, 0);
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 50 64.94% 1 25.00%
fabian frederick fabian frederick 22 28.57% 1 25.00%
steven whitehouse steven whitehouse 4 5.19% 1 25.00%
zhao hongjiang zhao hongjiang 1 1.30% 1 25.00%
Total 77 100.00% 4 100.00%



static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
				size_t len)
{
	int error, val;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	error = kstrtoint(buf, 0, &val);
	if (error)
		return error;

	if (val != 1)
		return -EINVAL;

	gfs2_quota_sync(sdp->sd_vfs, 0);
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 50 64.94% 1 25.00%
fabian frederick fabian frederick 22 28.57% 1 25.00%
steven whitehouse steven whitehouse 4 5.19% 1 25.00%
zhao hongjiang zhao hongjiang 1 1.30% 1 25.00%
Total 77 100.00% 4 100.00%



static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf,
					size_t len)
{
	struct kqid qid;
	int error;
	u32 id;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	error = kstrtou32(buf, 0, &id);
	if (error)
		return error;

	qid = make_kqid(current_user_ns(), USRQUOTA, id);
	if (!qid_valid(qid))
		return -EINVAL;

	error = gfs2_quota_refresh(sdp, qid);
	return error ? error : len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 48 48.00% 1 16.67%
eric w. biederman eric w. biederman 29 29.00% 1 16.67%
fabian frederick fabian frederick 12 12.00% 1 16.67%
steven whitehouse steven whitehouse 10 10.00% 2 33.33%
zhao hongjiang zhao hongjiang 1 1.00% 1 16.67%
Total 100 100.00% 6 100.00%



static ssize_t quota_refresh_group_store(struct gfs2_sbd *sdp, const char *buf,
					 size_t len)
{
	struct kqid qid;
	int error;
	u32 id;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	error = kstrtou32(buf, 0, &id);
	if (error)
		return error;

	qid = make_kqid(current_user_ns(), GRPQUOTA, id);
	if (!qid_valid(qid))
		return -EINVAL;

	error = gfs2_quota_refresh(sdp, qid);
	return error ? error : len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 48 48.00% 1 16.67%
eric w. biederman eric w. biederman 29 29.00% 1 16.67%
fabian frederick fabian frederick 12 12.00% 1 16.67%
steven whitehouse steven whitehouse 10 10.00% 2 33.33%
zhao hongjiang zhao hongjiang 1 1.00% 1 16.67%
Total 100 100.00% 6 100.00%



static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	struct gfs2_glock *gl;
	const struct gfs2_glock_operations *glops;
	unsigned int glmode;
	unsigned int gltype;
	unsigned long long glnum;
	char mode[16];
	int rv;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	rv = sscanf(buf, "%u:%llu %15s", &gltype, &glnum,
		    mode);
	if (rv != 3)
		return -EINVAL;

	if (strcmp(mode, "EX") == 0)
		glmode = LM_ST_UNLOCKED;
	else if ((strcmp(mode, "CW") == 0) || (strcmp(mode, "DF") == 0))
		glmode = LM_ST_DEFERRED;
	else if ((strcmp(mode, "PR") == 0) || (strcmp(mode, "SH") == 0))
		glmode = LM_ST_SHARED;
	else
		return -EINVAL;

	if (gltype > LM_TYPE_JOURNAL)
		return -EINVAL;
	if (gltype == LM_TYPE_NONDISK && glnum == GFS2_FREEZE_LOCK)
		glops = &gfs2_freeze_glops;
	else
		glops = gfs2_glops_list[gltype];
	if (glops == NULL)
		return -EINVAL;
	if (!test_and_set_bit(SDF_DEMOTE, &sdp->sd_flags))
		fs_info(sdp, "demote interface used\n");
	rv = gfs2_glock_get(sdp, glnum, glops, 0, &gl);
	if (rv)
		return rv;
	gfs2_glock_cb(gl, glmode);
	gfs2_glock_put(gl);
	return len;
}


Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 267 98.89% 4 66.67%
benjamin marzinski benjamin marzinski 2 0.74% 1 16.67%
zhao hongjiang zhao hongjiang 1 0.37% 1 16.67%
Total 270 100.00% 6 100.00%


#define GFS2_ATTR(name, mode, show, store) \
static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)

GFS2_ATTR(id,                  0444, id_show,       NULL);
GFS2_ATTR(fsname,              0444, fsname_show,   NULL);
GFS2_ATTR(uuid,                0444, uuid_show,     NULL);
GFS2_ATTR(freeze,              0644, freeze_show,   freeze_store);
GFS2_ATTR(withdraw,            0644, withdraw_show, withdraw_store);
GFS2_ATTR(statfs_sync,         0200, NULL,          statfs_sync_store);
GFS2_ATTR(quota_sync,          0200, NULL,          quota_sync_store);
GFS2_ATTR(quota_refresh_user,  0200, NULL,          quota_refresh_user_store);
GFS2_ATTR(quota_refresh_group, 0200, NULL,          quota_refresh_group_store);
GFS2_ATTR(demote_rq,           0200, NULL,	    demote_rq_store);


static struct attribute *gfs2_attrs[] = {
	&gfs2_attr_id.attr,
	&gfs2_attr_fsname.attr,
	&gfs2_attr_uuid.attr,
	&gfs2_attr_freeze.attr,
	&gfs2_attr_withdraw.attr,
	&gfs2_attr_statfs_sync.attr,
	&gfs2_attr_quota_sync.attr,
	&gfs2_attr_quota_refresh_user.attr,
	&gfs2_attr_quota_refresh_group.attr,
	&gfs2_attr_demote_rq.attr,
	NULL,
};



static void gfs2_sbd_release(struct kobject *kobj)
{
	struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);

	kfree(sdp);
}

Contributors
Person Tokens Prop Commits CommitProp
robert s. peterson robert s. peterson 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%


static struct kobj_type gfs2_ktype = {
	.release = gfs2_sbd_release,
	.default_attrs = gfs2_attrs,
	.sysfs_ops     = &gfs2_attr_ops,
};


/*
 * lock_module. Originally from lock_dlm
 */



static ssize_t proto_name_show(struct gfs2_sbd *sdp, char *buf)
{
	const struct lm_lockops *ops = sdp->sd_lockstruct.ls_ops;
	return sprintf(buf, "%s\n", ops->lm_proto_name);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%



static ssize_t block_show(struct gfs2_sbd *sdp, char *buf)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	ssize_t ret;
	int val = 0;

	if (test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))
		val = 1;
	ret = sprintf(buf, "%d\n", val);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 62 98.41% 1 50.00%
david teigland david teigland 1 1.59% 1 50.00%
Total 63 100.00% 2 100.00%



static ssize_t block_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	int ret, val;

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

	if (val == 1)
		set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
	else if (val == 0) {
		clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
		smp_mb__after_atomic();
		gfs2_glock_thaw(sdp);
	} else {
		return -EINVAL;
	}
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 86 81.13% 1 25.00%
fabian frederick fabian frederick 17 16.04% 1 25.00%
david teigland david teigland 2 1.89% 1 25.00%
peter zijlstra peter zijlstra 1 0.94% 1 25.00%
Total 106 100.00% 4 100.00%



static ssize_t wdack_show(struct gfs2_sbd *sdp, char *buf)
{
	int val = completion_done(&sdp->sd_wdack) ? 1 : 0;

	return sprintf(buf, "%d\n", val);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%



static ssize_t wdack_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	int ret, val;

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

	if ((val == 1) &&
	    !strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
		complete(&sdp->sd_wdack);
	else
		return -EINVAL;
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 64 79.01% 1 50.00%
fabian frederick fabian frederick 17 20.99% 1 50.00%
Total 81 100.00% 2 100.00%



static ssize_t lkfirst_show(struct gfs2_sbd *sdp, char *buf)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	return sprintf(buf, "%d\n", ls->ls_first);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



static ssize_t lkfirst_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	unsigned first;
	int rv;

	rv = sscanf(buf, "%u", &first);
	if (rv != 1 || first > 1)
		return -EINVAL;
	rv = wait_for_completion_killable(&sdp->sd_locking_init);
	if (rv)
		return rv;
	spin_lock(&sdp->sd_jindex_spin);
	rv = -EBUSY;
	if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
		goto out;
	rv = -EINVAL;
	if (sdp->sd_args.ar_spectator)
		goto out;
	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
		goto out;
	sdp->sd_lockstruct.ls_first = first;
	rv = 0;
out:
        spin_unlock(&sdp->sd_jindex_spin);
        return rv ? rv : len;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 158 100.00% 2 100.00%
Total 158 100.00% 2 100.00%



static ssize_t first_done_show(struct gfs2_sbd *sdp, char *buf)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	return sprintf(buf, "%d\n", !!test_bit(DFL_FIRST_MOUNT_DONE, &ls->ls_recover_flags));
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 36 80.00% 1 50.00%
david teigland david teigland 9 20.00% 1 50.00%
Total 45 100.00% 2 100.00%



int gfs2_recover_set(struct gfs2_sbd *sdp, unsigned jid)
{
	struct gfs2_jdesc *jd;
	int rv;

	/* Wait for our primary journal to be initialized */
	wait_for_completion(&sdp->sd_journal_ready);

	spin_lock(&sdp->sd_jindex_spin);
	rv = -EBUSY;
	if (sdp->sd_jdesc->jd_jid == jid)
		goto out;
	rv = -ENOENT;
	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
		if (jd->jd_jid != jid)
			continue;
		rv = gfs2_recover_journal(jd, false);
		break;
	}
out:
	spin_unlock(&sdp->sd_jindex_spin);
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 85 82.52% 2 40.00%
robert s. peterson robert s. peterson 9 8.74% 1 20.00%
david teigland david teigland 6 5.83% 1 20.00%
tejun heo tejun heo 3 2.91% 1 20.00%
Total 103 100.00% 5 100.00%



static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
	unsigned jid;
	int rv;

	rv = sscanf(buf, "%u", &jid);
	if (rv != 1)
		return -EINVAL;

	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags)) {
		rv = -ESHUTDOWN;
		goto out;
	}

	rv = gfs2_recover_set(sdp, jid);
out:
	return rv ? rv : len;
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 81 93.10% 2 50.00%
steven whitehouse steven whitehouse 6 6.90% 2 50.00%
Total 87 100.00% 4 100.00%



static ssize_t recover_done_show(struct gfs2_sbd *sdp, char *buf)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	return sprintf(buf, "%d\n", ls->ls_recover_jid_done);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



static ssize_t recover_status_show(struct gfs2_sbd *sdp, char *buf)
{
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
	return sprintf(buf, "%d\n", ls->ls_recover_jid_status);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 31 83.78% 1 50.00%
david teigland david teigland 6 16.22% 1 50.00%
Total 37 100.00% 2 100.00%



static ssize_t jid_show(struct gfs2_sbd *sdp, char *buf)
{
	return sprintf(buf, "%d\n", sdp->sd_lockstruct.ls_jid);
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 29 100.00% 2 100.00%
Total 29 100.00% 2 100.00%



static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
{
        int jid;
	int rv;

	rv = sscanf(buf, "%d", &jid);
	if (rv != 1)
		return -EINVAL;
	rv = wait_for_completion_killable(&sdp->sd_locking_init);
	if (rv)
		return rv;
	spin_lock(&sdp->sd_jindex_spin);
	rv = -EINVAL;
	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
		goto out;
	rv = -EBUSY;
	if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
		goto out;
	rv = 0;
	if (sdp->sd_args.ar_spectator && jid > 0)
		rv = jid = -EINVAL;
	sdp->sd_lockstruct.ls_jid = jid;
	clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
	smp_mb__after_atomic();
	wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
out:
	spin_unlock(&sdp->sd_jindex_spin);
	return rv ? rv : len;
}

Contributors
Person Tokens Prop Commits CommitProp
steven whitehouse steven whitehouse 184 99.46% 3 75.00%
peter zijlstra peter zijlstra 1 0.54% 1 25.00%
Total 185 100.00% 4 100.00%


#define GDLM_ATTR(_name,_mode,_show,_store) \
static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)

GDLM_ATTR(proto_name,		0444, proto_name_show,		NULL);
GDLM_ATTR(block,		0644, block_show,		block_store);
GDLM_ATTR(withdraw,		0644, wdack_show,		wdack_store);
GDLM_ATTR(jid,			0644, jid_show,			jid_store);
GDLM_ATTR(first,		0644, lkfirst_show,		lkfirst_store);
GDLM_ATTR(first_done,		0444, first_done_show,		NULL);
GDLM_ATTR(recover,		0600, NULL,			recover_store);
GDLM_ATTR(recover_done,		0444, recover_done_show,	NULL);
GDLM_ATTR(recover_status,	0444, recover_status_show,	NULL);


static struct attribute *lock_module_attrs[] = {
	&gdlm_attr_proto_name.attr,
	&gdlm_attr_block.attr,
	&gdlm_attr_withdraw.attr,
	&gdlm_attr_jid.attr,
	&gdlm_attr_first.attr,
	&gdlm_attr_first_done.attr,
	&gdlm_attr_recover.attr,
	&gdlm_attr_recover_done.attr,
	&gdlm_attr_recover_status.attr,
	NULL,
};

/*
 * get and set struct gfs2_tune fields
 */



static ssize_t quota_scale_show(struct gfs2_sbd *sdp, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%u %u\n",
			sdp->sd_tune.gt_quota_scale_num,
			sdp->sd_tune.gt_quota_scale_den);
}

Contributors
Person Tokens Prop Commits CommitProp
david teigland david teigland 37 100.00% 2 100.00%
Total 37 100.00% 2 100.00%



static ssize_t quota_scale_store(struct gfs2_sbd *sdp, const char *buf,
				 size_t len)
{
	struct gfs2_tune *gt = &sdp->sd_tune;
	unsigned int x, y;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (sscanf(buf, "%u %u", &x, &y) != 2 || !y)
		return -EINVAL;

	spin_lock(&gt->gt_spin);
	gt->gt_quota_scale_num = x;
	gt->gt_quota_scale_den = y;
	spin_unlock(&gt
	Person	Tokens	Prop	Commits	CommitProp
steven whitehouse	steven whitehouse	66	100.00%	1	100.00%
	Total	66	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/gfs2/sys.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
