LXR linux/fs/quota/kqid.c

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