cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

kqid.c (3284B)

      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);