LXR linux/fs/quota/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);
 134