kqid.c

  1// SPDX-License-Identifier: GPL-2.0
  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 */
 13bool 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}
 28EXPORT_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 */
 37bool 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}
 54EXPORT_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.
 59 *	@kqid: The kernel internal quota identifier to start with.
 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 */
 68qid_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}
 81EXPORT_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 */
101qid_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}
114EXPORT_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 */
120bool 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}
133EXPORT_SYMBOL(qid_valid);