Whamcloud - gitweb
LU-12616 obclass: fix MDS start/stop race
[fs/lustre-release.git] / lustre / osc / osc_quota.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 021110-1307, USA
20  *
21  * GPL HEADER END
22  */
23 /*
24  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  *
28  * Code originally extracted from quota directory
29  */
30
31 #include <obd.h>
32 #include <lustre_osc.h>
33
34 #include "osc_internal.h"
35
36 static inline struct osc_quota_info *osc_oqi_alloc(u32 id)
37 {
38         struct osc_quota_info *oqi;
39
40         OBD_SLAB_ALLOC_PTR(oqi, osc_quota_kmem);
41         if (oqi != NULL)
42                 oqi->oqi_id = id;
43
44         return oqi;
45 }
46
47 int osc_quota_chkdq(struct client_obd *cli, const unsigned int qid[])
48 {
49         int type;
50         ENTRY;
51
52         for (type = 0; type < LL_MAXQUOTAS; type++) {
53                 struct osc_quota_info *oqi;
54
55                 oqi = cfs_hash_lookup(cli->cl_quota_hash[type], &qid[type]);
56                 if (oqi) {
57                         /* do not try to access oqi here, it could have been
58                          * freed by osc_quota_setdq() */
59
60                         /* the slot is busy, the user is about to run out of
61                          * quota space on this OST */
62                         CDEBUG(D_QUOTA, "chkdq found noquota for %s %d\n",
63                                type == USRQUOTA ? "user" : "grout", qid[type]);
64                         RETURN(NO_QUOTA);
65                 }
66         }
67
68         RETURN(QUOTA_OK);
69 }
70
71 static inline u32 md_quota_flag(int qtype)
72 {
73         switch (qtype) {
74         case USRQUOTA:
75                 return OBD_MD_FLUSRQUOTA;
76         case GRPQUOTA:
77                 return OBD_MD_FLGRPQUOTA;
78         case PRJQUOTA:
79                 return OBD_MD_FLPRJQUOTA;
80         default:
81                 return 0;
82         }
83 }
84
85 static inline u32 fl_quota_flag(int qtype)
86 {
87         switch (qtype) {
88         case USRQUOTA:
89                 return OBD_FL_NO_USRQUOTA;
90         case GRPQUOTA:
91                 return OBD_FL_NO_GRPQUOTA;
92         case PRJQUOTA:
93                 return OBD_FL_NO_PRJQUOTA;
94         default:
95                 return 0;
96         }
97 }
98
99 int osc_quota_setdq(struct client_obd *cli, __u64 xid, const unsigned int qid[],
100                     u64 valid, u32 flags)
101 {
102         int type;
103         int rc = 0;
104
105         ENTRY;
106
107         if ((valid & (OBD_MD_FLALLQUOTA)) == 0)
108                 RETURN(0);
109
110         mutex_lock(&cli->cl_quota_mutex);
111         /* still mark the quots is running out for the old request, because it
112          * could be processed after the new request at OST, the side effect is
113          * the following request will be processed synchronously, but it will
114          * not break the quota enforcement. */
115         if (cli->cl_quota_last_xid > xid && !(flags & OBD_FL_NO_QUOTA_ALL))
116                 GOTO(out_unlock, rc);
117
118         if (cli->cl_quota_last_xid < xid)
119                 cli->cl_quota_last_xid = xid;
120
121         for (type = 0; type < LL_MAXQUOTAS; type++) {
122                 struct osc_quota_info *oqi;
123
124                 if ((valid & md_quota_flag(type)) == 0)
125                         continue;
126
127                 /* lookup the ID in the per-type hash table */
128                 oqi = cfs_hash_lookup(cli->cl_quota_hash[type], &qid[type]);
129                 if ((flags & fl_quota_flag(type)) != 0) {
130                         /* This ID is getting close to its quota limit, let's
131                          * switch to sync I/O */
132                         if (oqi != NULL)
133                                 continue;
134
135                         oqi = osc_oqi_alloc(qid[type]);
136                         if (oqi == NULL) {
137                                 rc = -ENOMEM;
138                                 break;
139                         }
140
141                         rc = cfs_hash_add_unique(cli->cl_quota_hash[type],
142                                                  &qid[type], &oqi->oqi_hash);
143                         /* race with others? */
144                         if (rc == -EALREADY) {
145                                 rc = 0;
146                                 OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
147                         }
148
149                         CDEBUG(D_QUOTA, "%s: setdq to insert for %s %d (%d)\n",
150                                cli_name(cli), qtype_name(type), qid[type], rc);
151                 } else {
152                         /* This ID is now off the hook, let's remove it from
153                          * the hash table */
154                         if (oqi == NULL)
155                                 continue;
156
157                         oqi = cfs_hash_del_key(cli->cl_quota_hash[type],
158                                                &qid[type]);
159                         if (oqi)
160                                 OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
161
162                         CDEBUG(D_QUOTA, "%s: setdq to remove for %s %d (%p)\n",
163                                cli_name(cli), qtype_name(type), qid[type], oqi);
164                 }
165         }
166
167 out_unlock:
168         mutex_unlock(&cli->cl_quota_mutex);
169         RETURN(rc);
170 }
171
172 /*
173  * Hash operations for uid/gid <-> osc_quota_info
174  */
175 static unsigned
176 oqi_hashfn(struct cfs_hash *hs, const void *key, unsigned mask)
177 {
178         return cfs_hash_u32_hash(*((__u32*)key), mask);
179 }
180
181 static int
182 oqi_keycmp(const void *key, struct hlist_node *hnode)
183 {
184         struct osc_quota_info *oqi;
185         u32 uid;
186
187         LASSERT(key != NULL);
188         uid = *((u32 *)key);
189         oqi = hlist_entry(hnode, struct osc_quota_info, oqi_hash);
190
191         return uid == oqi->oqi_id;
192 }
193
194 static void *
195 oqi_key(struct hlist_node *hnode)
196 {
197         struct osc_quota_info *oqi;
198         oqi = hlist_entry(hnode, struct osc_quota_info, oqi_hash);
199         return &oqi->oqi_id;
200 }
201
202 static void *
203 oqi_object(struct hlist_node *hnode)
204 {
205         return hlist_entry(hnode, struct osc_quota_info, oqi_hash);
206 }
207
208 static void
209 oqi_get(struct cfs_hash *hs, struct hlist_node *hnode)
210 {
211 }
212
213 static void
214 oqi_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
215 {
216 }
217
218 static void
219 oqi_exit(struct cfs_hash *hs, struct hlist_node *hnode)
220 {
221         struct osc_quota_info *oqi;
222
223         oqi = hlist_entry(hnode, struct osc_quota_info, oqi_hash);
224
225         OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
226 }
227
228 #define HASH_QUOTA_BKT_BITS 5
229 #define HASH_QUOTA_CUR_BITS 5
230 #define HASH_QUOTA_MAX_BITS 15
231
232 static struct cfs_hash_ops quota_hash_ops = {
233         .hs_hash        = oqi_hashfn,
234         .hs_keycmp      = oqi_keycmp,
235         .hs_key         = oqi_key,
236         .hs_object      = oqi_object,
237         .hs_get         = oqi_get,
238         .hs_put_locked  = oqi_put_locked,
239         .hs_exit        = oqi_exit,
240 };
241
242 int osc_quota_setup(struct obd_device *obd)
243 {
244         struct client_obd *cli = &obd->u.cli;
245         int i, type;
246         ENTRY;
247
248         mutex_init(&cli->cl_quota_mutex);
249
250         for (type = 0; type < LL_MAXQUOTAS; type++) {
251                 cli->cl_quota_hash[type] = cfs_hash_create("QUOTA_HASH",
252                                                            HASH_QUOTA_CUR_BITS,
253                                                            HASH_QUOTA_MAX_BITS,
254                                                            HASH_QUOTA_BKT_BITS,
255                                                            0,
256                                                            CFS_HASH_MIN_THETA,
257                                                            CFS_HASH_MAX_THETA,
258                                                            &quota_hash_ops,
259                                                            CFS_HASH_DEFAULT);
260                 if (cli->cl_quota_hash[type] == NULL)
261                         break;
262         }
263
264         if (type == LL_MAXQUOTAS)
265                 RETURN(0);
266
267         for (i = 0; i < type; i++)
268                 cfs_hash_putref(cli->cl_quota_hash[i]);
269
270         RETURN(-ENOMEM);
271 }
272
273 int osc_quota_cleanup(struct obd_device *obd)
274 {
275         struct client_obd     *cli = &obd->u.cli;
276         int type;
277         ENTRY;
278
279         for (type = 0; type < LL_MAXQUOTAS; type++)
280                 cfs_hash_putref(cli->cl_quota_hash[type]);
281
282         RETURN(0);
283 }
284
285 int osc_quotactl(struct obd_device *unused, struct obd_export *exp,
286                  struct obd_quotactl *oqctl)
287 {
288         struct ptlrpc_request *req;
289         struct obd_quotactl   *oqc;
290         int                    rc;
291         ENTRY;
292
293         req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
294                                         &RQF_OST_QUOTACTL, LUSTRE_OST_VERSION,
295                                         OST_QUOTACTL);
296         if (req == NULL)
297                 RETURN(-ENOMEM);
298
299         oqc = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
300         *oqc = *oqctl;
301
302         ptlrpc_request_set_replen(req);
303         ptlrpc_at_set_req_timeout(req);
304         req->rq_no_resend = 1;
305
306         rc = ptlrpc_queue_wait(req);
307         if (rc)
308                 CERROR("ptlrpc_queue_wait failed, rc: %d\n", rc);
309
310         if (req->rq_repmsg &&
311             (oqc = req_capsule_server_get(&req->rq_pill, &RMF_OBD_QUOTACTL))) {
312                 *oqctl = *oqc;
313         } else if (!rc) {
314                 CERROR ("Can't unpack obd_quotactl\n");
315                 rc = -EPROTO;
316         }
317         ptlrpc_req_finished(req);
318
319         RETURN(rc);
320 }