[thirdparty/linux.git] / fs / quota / kqid.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/fs.h>
#include <linux/quota.h>
#include <linux/export.h>

/**
 *	qid_eq - Test to see if to kquid values are the same
 *	@left: A qid value
 *	@right: Another quid value
 *
 *	Return true if the two qid values are equal and false otherwise.
 */
bool qid_eq(struct kqid left, struct kqid right)
{
	if (left.type != right.type)
		return false;
	switch(left.type) {
	case USRQUOTA:
		return uid_eq(left.uid, right.uid);
	case GRPQUOTA:
		return gid_eq(left.gid, right.gid);
	case PRJQUOTA:
		return projid_eq(left.projid, right.projid);
	default:
		BUG();
	}
}
EXPORT_SYMBOL(qid_eq);

/**
 *	qid_lt - Test to see if one qid value is less than another
 *	@left: The possibly lesser qid value
 *	@right: The possibly greater qid value
 *
 *	Return true if left is less than right and false otherwise.
 */
bool qid_lt(struct kqid left, struct kqid right)
{
	if (left.type < right.type)
		return true;
	if (left.type > right.type)
		return false;
	switch (left.type) {
	case USRQUOTA:
		return uid_lt(left.uid, right.uid);
	case GRPQUOTA:
		return gid_lt(left.gid, right.gid);
	case PRJQUOTA:
		return projid_lt(left.projid, right.projid);
	default:
		BUG();
	}
}
EXPORT_SYMBOL(qid_lt);

/**
 *	from_kqid - Create a qid from a kqid user-namespace pair.
 *	@targ: The user namespace we want a qid in.
 *	@kqid: The kernel internal quota identifier to start with.
 *
 *	Map @kqid into the user-namespace specified by @targ and
 *	return the resulting qid.
 *
 *	There is always a mapping into the initial user_namespace.
 *
 *	If @kqid has no mapping in @targ (qid_t)-1 is returned.
 */
qid_t from_kqid(struct user_namespace *targ, struct kqid kqid)
{
	switch (kqid.type) {
	case USRQUOTA:
		return from_kuid(targ, kqid.uid);
	case GRPQUOTA:
		return from_kgid(targ, kqid.gid);
	case PRJQUOTA:
		return from_kprojid(targ, kqid.projid);
	default:
		BUG();
	}
}
EXPORT_SYMBOL(from_kqid);

/**
 *	from_kqid_munged - Create a qid from a kqid user-namespace pair.
 *	@targ: The user namespace we want a qid in.
 *	@kqid: The kernel internal quota identifier to start with.
 *
 *	Map @kqid into the user-namespace specified by @targ and
 *	return the resulting qid.
 *
 *	There is always a mapping into the initial user_namespace.
 *
 *	Unlike from_kqid from_kqid_munged never fails and always
 *	returns a valid projid.  This makes from_kqid_munged
 *	appropriate for use in places where failing to provide
 *	a qid_t is not a good option.
 *
 *	If @kqid has no mapping in @targ the kqid.type specific
 *	overflow identifier is returned.
 */
qid_t from_kqid_munged(struct user_namespace *targ, struct kqid kqid)
{
	switch (kqid.type) {
	case USRQUOTA:
		return from_kuid_munged(targ, kqid.uid);
	case GRPQUOTA:
		return from_kgid_munged(targ, kqid.gid);
	case PRJQUOTA:
		return from_kprojid_munged(targ, kqid.projid);
	default:
		BUG();
	}
}
EXPORT_SYMBOL(from_kqid_munged);

/**
 *	qid_valid - Report if a valid value is stored in a kqid.
 *	@qid: The kernel internal quota identifier to test.
 */
bool qid_valid(struct kqid qid)
{
	switch (qid.type) {
	case USRQUOTA:
		return uid_valid(qid.uid);
	case GRPQUOTA:
		return gid_valid(qid.gid);
	case PRJQUOTA:
		return projid_valid(qid.projid);
	default:
		BUG();
	}
}
EXPORT_SYMBOL(qid_valid);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
e8a3e471 EB	2	#include <linux/fs.h>
	3	#include <linux/quota.h>
	4	#include <linux/export.h>
	5
	6	/**
	7	* qid_eq - Test to see if to kquid values are the same
	8	* @left: A qid value
	9	* @right: Another quid value
	10	*
	11	* Return true if the two qid values are equal and false otherwise.
	12	*/
	13	bool qid_eq(struct kqid left, struct kqid right)
	14	{
	15	if (left.type != right.type)
	16	return false;
	17	switch(left.type) {
	18	case USRQUOTA:
	19	return uid_eq(left.uid, right.uid);
	20	case GRPQUOTA:
	21	return gid_eq(left.gid, right.gid);
	22	case PRJQUOTA:
	23	return projid_eq(left.projid, right.projid);
	24	default:
	25	BUG();
	26	}
	27	}
	28	EXPORT_SYMBOL(qid_eq);
	29
	30	/**
	31	* qid_lt - Test to see if one qid value is less than another
	32	* @left: The possibly lesser qid value
	33	* @right: The possibly greater qid value
	34	*
	35	* Return true if left is less than right and false otherwise.
	36	*/
	37	bool qid_lt(struct kqid left, struct kqid right)
	38	{
	39	if (left.type < right.type)
	40	return true;
	41	if (left.type > right.type)
	42	return false;
	43	switch (left.type) {
	44	case USRQUOTA:
	45	return uid_lt(left.uid, right.uid);
	46	case GRPQUOTA:
	47	return gid_lt(left.gid, right.gid);
	48	case PRJQUOTA:
	49	return projid_lt(left.projid, right.projid);
	50	default:
	51	BUG();
	52	}
	53	}
	54	EXPORT_SYMBOL(qid_lt);
	55
	56	/**
	57	* from_kqid - Create a qid from a kqid user-namespace pair.
	58	* @targ: The user namespace we want a qid in.
2c15ac5b	59	* @kqid: The kernel internal quota identifier to start with.
e8a3e471 EB	60	*
	61	* Map @kqid into the user-namespace specified by @targ and
	62	* return the resulting qid.
	63	*
	64	* There is always a mapping into the initial user_namespace.
	65	*
	66	* If @kqid has no mapping in @targ (qid_t)-1 is returned.
	67	*/
	68	qid_t from_kqid(struct user_namespace *targ, struct kqid kqid)
	69	{
	70	switch (kqid.type) {
	71	case USRQUOTA:
	72	return from_kuid(targ, kqid.uid);
	73	case GRPQUOTA:
	74	return from_kgid(targ, kqid.gid);
	75	case PRJQUOTA:
	76	return from_kprojid(targ, kqid.projid);
	77	default:
	78	BUG();
	79	}
	80	}
	81	EXPORT_SYMBOL(from_kqid);
	82
	83	/**
	84	* from_kqid_munged - Create a qid from a kqid user-namespace pair.
	85	* @targ: The user namespace we want a qid in.
	86	* @kqid: The kernel internal quota identifier to start with.
	87	*
	88	* Map @kqid into the user-namespace specified by @targ and
	89	* return the resulting qid.
	90	*
	91	* There is always a mapping into the initial user_namespace.
	92	*
	93	* Unlike from_kqid from_kqid_munged never fails and always
	94	* returns a valid projid. This makes from_kqid_munged
	95	* appropriate for use in places where failing to provide
	96	* a qid_t is not a good option.
	97	*
	98	* If @kqid has no mapping in @targ the kqid.type specific
	99	* overflow identifier is returned.
	100	*/
	101	qid_t from_kqid_munged(struct user_namespace *targ, struct kqid kqid)
	102	{
	103	switch (kqid.type) {
	104	case USRQUOTA:
	105	return from_kuid_munged(targ, kqid.uid);
	106	case GRPQUOTA:
	107	return from_kgid_munged(targ, kqid.gid);
	108	case PRJQUOTA:
	109	return from_kprojid_munged(targ, kqid.projid);
	110	default:
	111	BUG();
	112	}
	113	}
	114	EXPORT_SYMBOL(from_kqid_munged);
	115
	116	/**
	117	* qid_valid - Report if a valid value is stored in a kqid.
	118	* @qid: The kernel internal quota identifier to test.
	119	*/
	120	bool qid_valid(struct kqid qid)
	121	{
	122	switch (qid.type) {
	123	case USRQUOTA:
124	return uid_valid(qid.uid);
125	case GRPQUOTA:
126	return gid_valid(qid.gid);
127	case PRJQUOTA:
128	return projid_valid(qid.projid);
129	default:
130	BUG();
131	}
132	}
133	EXPORT_SYMBOL(qid_valid);