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