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  */
  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.
  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  */
  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);