Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
e8a3e471 EB |
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. | |
2c15ac5b | 59 | * @kqid: The kernel internal quota identifier to start with. |
e8a3e471 EB |
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); |