Whamcloud - gitweb
LU-709 build: clean up quota_read, follow_link and RCU
[fs/lustre-release.git] / lustre / lvfs / quotafmt_test.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, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  * Lustre is a trademark of Sun Microsystems, Inc.
33  *
34  * lustre/lvfs/quotafmt_test.c
35  *
36  * No redistribution or use is permitted outside of Sun Microsystems, Inc.
37  *
38  * Kernel module to test lustre administrative quotafile format APIs
39  * from the OBD setup function
40  */
41
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/errno.h>
45 #include <linux/fs.h>
46 #include <linux/kernel.h>
47
48 #include <lustre_quota.h>
49 #include <obd_class.h>
50
51 #include "lustre_quota_fmt.h"
52
53 #ifdef HAVE_QUOTA_SUPPORT
54
55 char *test_quotafile[2] = { "usrquota_test", "grpquota_test" };
56
57 static int quotfmt_initialize(struct lustre_quota_info *lqi,
58                               struct obd_device *tgt,
59                               struct lvfs_run_ctxt *saved)
60 {
61         struct lustre_disk_dqheader dqhead;
62         static const uint quota_magics[] = LUSTRE_INITQMAGICS;
63         static const uint quota_versions[] = LUSTRE_INITQVERSIONS_V2;
64         struct file *fp;
65         struct inode *parent_inode = tgt->obd_lvfs_ctxt.pwd->d_inode;
66         size_t size;
67         struct dentry *de;
68         int i, rc = 0;
69         ENTRY;
70
71         push_ctxt(saved, &tgt->obd_lvfs_ctxt, NULL);
72
73         for (i = 0; i < MAXQUOTAS; i++) {
74                 loff_t offset = 0;
75                 char *name = test_quotafile[i];
76                 int namelen = strlen(name);
77
78                 /* remove the stale test quotafile */
79                 LOCK_INODE_MUTEX_PARENT(parent_inode);
80                 de = lookup_one_len(name, tgt->obd_lvfs_ctxt.pwd, namelen);
81                 if (!IS_ERR(de) && de->d_inode)
82                         ll_vfs_unlink(parent_inode, de,
83                                       tgt->obd_lvfs_ctxt.pwdmnt);
84                 if (!IS_ERR(de))
85                         dput(de);
86                 UNLOCK_INODE_MUTEX(parent_inode);
87
88                 /* create quota file */
89                 fp = filp_open(name, O_CREAT | O_EXCL, 0644);
90                 if (IS_ERR(fp)) {
91                         rc = PTR_ERR(fp);
92                         CERROR("error creating test quotafile %s (rc = %d)\n",
93                                name, rc);
94                         break;
95                 }
96                 lqi->qi_files[i] = fp;
97
98                 /* write quotafile header */
99                 dqhead.dqh_magic = cpu_to_le32(quota_magics[i]);
100                 dqhead.dqh_version = cpu_to_le32(quota_versions[i]);
101                 size = fp->f_op->write(fp, (char *)&dqhead,
102                                        sizeof(struct lustre_disk_dqheader),
103                                        &offset);
104                 if (size != sizeof(struct lustre_disk_dqheader)) {
105                         CERROR("error writing quotafile header %s (rc = %d)\n",
106                                name, rc);
107                         rc = size;
108                         break;
109                 }
110         }
111
112         RETURN(rc);
113 }
114
115 static int quotfmt_finalize(struct lustre_quota_info *lqi,
116                             struct obd_device *tgt, struct lvfs_run_ctxt *saved)
117 {
118         struct dentry *de;
119         struct inode *parent_inode = tgt->obd_lvfs_ctxt.pwd->d_inode;
120         int i, rc = 0;
121         ENTRY;
122
123         for (i = 0; i < MAXQUOTAS; i++) {
124                 char *name = test_quotafile[i];
125                 int namelen = strlen(name);
126
127                 if (lqi->qi_files[i] == NULL)
128                         continue;
129
130                 /* close quota file */
131                 filp_close(lqi->qi_files[i], 0);
132
133                 /* unlink quota file */
134                 LOCK_INODE_MUTEX_PARENT(parent_inode);
135
136                 de = lookup_one_len(name, tgt->obd_lvfs_ctxt.pwd, namelen);
137                 if (IS_ERR(de) || de->d_inode == NULL) {
138                         rc = IS_ERR(de) ? PTR_ERR(de) : -ENOENT;
139                         CERROR("error lookup quotafile %s (rc = %d)\n",
140                                name, rc);
141                         goto dput;
142                 }
143
144                 rc = ll_vfs_unlink(parent_inode, de, tgt->obd_lvfs_ctxt.pwdmnt);
145                 if (rc)
146                         CERROR("error unlink quotafile %s (rc = %d)\n",
147                                name, rc);
148               dput:
149                 if (!IS_ERR(de))
150                         dput(de);
151                 UNLOCK_INODE_MUTEX(parent_inode);
152         }
153
154         pop_ctxt(saved, &tgt->obd_lvfs_ctxt, NULL);
155         RETURN(rc);
156 }
157
158 static int quotfmt_test_1(struct lustre_quota_info *lqi)
159 {
160         int i;
161         ENTRY;
162
163         for (i = 0; i < MAXQUOTAS; i++) {
164                 if (lustre_check_quota_file(lqi, i))
165                         RETURN(-EINVAL);
166         }
167         RETURN(0);
168 }
169
170 static void print_quota_info(struct lustre_quota_info *lqi)
171 {
172 #if 0
173         struct lustre_mem_dqinfo *dqinfo;
174         int i;
175
176         for (i = 0; i < MAXQUOTAS; i++) {
177                 dqinfo = &lqi->qi_info[i];
178                 CDEBUG(D_INFO, "%s quota info:\n", i == USRQUOTA ? "user " : "group");
179                 CDEBUG(D_INFO, "dqi_bgrace(%u) dqi_igrace(%u) dqi_flags(%lu) dqi_blocks(%u) "
180                        "dqi_free_blk(%u) dqi_free_entry(%u)\n",
181                        dqinfo->dqi_bgrace, dqinfo->dqi_igrace, dqinfo->dqi_flags,
182                        dqinfo->dqi_blocks, dqinfo->dqi_free_blk,
183                        dqinfo->dqi_free_entry);
184         }
185 #endif
186 }
187
188 static int quotfmt_test_2(struct lustre_quota_info *lqi)
189 {
190         int i, rc = 0;
191         ENTRY;
192
193         for (i = 0; i < MAXQUOTAS; i++) {
194                 struct lustre_mem_dqinfo dqinfo;
195
196                 rc = lustre_init_quota_info(lqi, i);
197                 if (rc) {
198                         CERROR("init quotainfo(%d) failed! (rc:%d)\n", i, rc);
199                         break;
200                 }
201                 memcpy(&dqinfo, &lqi->qi_info[i], sizeof(dqinfo));
202
203                 rc = lustre_read_quota_info(lqi, i);
204                 if (rc) {
205                         CERROR("read quotainfo(%d) failed! (rc:%d)\n", i, rc);
206                         break;
207                 }
208
209                 if (memcmp(&dqinfo, &lqi->qi_info[i], sizeof(dqinfo))) {
210                         rc = -EINVAL;
211                         break;
212                 }
213         }
214         RETURN(rc);
215 }
216
217 static struct lustre_dquot *get_rand_dquot(struct lustre_quota_info *lqi)
218 {
219         struct lustre_dquot *dquot;
220         unsigned int rand;
221
222         OBD_ALLOC(dquot, sizeof(*dquot));
223         if (dquot == NULL)
224                 return NULL;
225
226         cfs_get_random_bytes(&rand, sizeof(rand));
227         if (!rand)
228                 rand = 1000;
229
230         dquot->dq_info = lqi;
231         dquot->dq_id = rand % 1000 + 1;
232         dquot->dq_type = rand % MAXQUOTAS;
233
234         dquot->dq_dqb.dqb_bhardlimit = rand;
235         dquot->dq_dqb.dqb_bsoftlimit = rand / 2;
236         dquot->dq_dqb.dqb_curspace = rand / 3;
237         dquot->dq_dqb.dqb_ihardlimit = rand;
238         dquot->dq_dqb.dqb_isoftlimit = rand / 2;
239         dquot->dq_dqb.dqb_curinodes = rand / 3;
240         dquot->dq_dqb.dqb_btime = jiffies;
241         dquot->dq_dqb.dqb_itime = jiffies;
242
243         return dquot;
244 }
245
246 static void put_rand_dquot(struct lustre_dquot *dquot)
247 {
248         OBD_FREE(dquot, sizeof(*dquot));
249 }
250
251 static int write_check_dquot(struct lustre_quota_info *lqi)
252 {
253         struct lustre_dquot *dquot;
254         struct lustre_mem_dqblk dqblk;
255         int rc = 0;
256         ENTRY;
257
258         dquot = get_rand_dquot(lqi);
259         if (dquot == NULL)
260                 RETURN(-ENOMEM);
261
262         /* for already exists entry, we set the dq_off by read_dquot */
263         rc = lustre_read_dquot(dquot);
264         if (rc) {
265                 CERROR("read dquot failed! (rc:%d)\n", rc);
266                 GOTO(out, rc);
267         }
268
269         cfs_clear_bit(DQ_FAKE_B, &dquot->dq_flags);
270         /* for already exists entry, we rewrite it */
271         rc = lustre_commit_dquot(dquot);
272         if (rc) {
273                 CERROR("commit dquot failed! (rc:%d)\n", rc);
274                 GOTO(out, rc);
275         }
276         memcpy(&dqblk, &dquot->dq_dqb, sizeof(dqblk));
277         memset(&dquot->dq_dqb, 0, sizeof(dqblk));
278
279         rc = lustre_read_dquot(dquot);
280         if (rc) {
281                 CERROR("read dquot failed! (rc:%d)\n", rc);
282                 GOTO(out, rc);
283         }
284
285         if (memcmp(&dqblk, &dquot->dq_dqb, sizeof(dqblk))) {
286                 rc = -EINVAL;
287                 GOTO(out, rc);
288         }
289       out:
290         put_rand_dquot(dquot);
291         RETURN(rc);
292 }
293
294 static int quotfmt_test_3(struct lustre_quota_info *lqi)
295 {
296         struct lustre_dquot *dquot;
297         int i = 0, rc = 0;
298         ENTRY;
299
300         dquot = get_rand_dquot(lqi);
301         if (dquot == NULL)
302                 RETURN(-ENOMEM);
303       repeat:
304         cfs_clear_bit(DQ_FAKE_B, &dquot->dq_flags);
305         /* write a new dquot */
306         rc = lustre_commit_dquot(dquot);
307         if (rc) {
308                 CERROR("commit dquot failed! (rc:%d)\n", rc);
309                 GOTO(out, rc);
310         }
311         dquot->dq_off = 0;
312         memset(&dquot->dq_dqb, 0, sizeof(dquot->dq_dqb));
313
314         /* check if this dquot is on disk now */
315         rc = lustre_read_dquot(dquot);
316         if (rc) {
317                 CERROR("read dquot failed! (rc:%d)\n", rc);
318                 GOTO(out, rc);
319         }
320         if (!dquot->dq_off || cfs_test_bit(DQ_FAKE_B, &dquot->dq_flags)) {
321                 CERROR("the dquot isn't committed\n");
322                 GOTO(out, rc = -EINVAL);
323         }
324
325         /* remove this dquot */
326         cfs_set_bit(DQ_FAKE_B, &dquot->dq_flags);
327         dquot->dq_dqb.dqb_curspace = 0;
328         dquot->dq_dqb.dqb_curinodes = 0;
329         rc = lustre_commit_dquot(dquot);
330         if (rc) {
331                 CERROR("remove dquot failed! (rc:%d)\n", rc);
332                 GOTO(out, rc);
333         }
334
335         /* check if the dquot is really removed */
336         cfs_clear_bit(DQ_FAKE_B, &dquot->dq_flags);
337         dquot->dq_off = 0;
338         rc = lustre_read_dquot(dquot);
339         if (rc) {
340                 CERROR("read dquot failed! (rc:%d)\n", rc);
341                 GOTO(out, rc);
342         }
343         if (!cfs_test_bit(DQ_FAKE_B, &dquot->dq_flags) || dquot->dq_off) {
344                 CERROR("the dquot isn't removed!\n");
345                 GOTO(out, rc = -EINVAL);
346         }
347
348         /* check if this dquot can be write again */
349         if (++i < 2)
350                 goto repeat;
351
352         print_quota_info(lqi);
353
354       out:
355         put_rand_dquot(dquot);
356         RETURN(rc);
357 }
358
359 static int quotfmt_test_4(struct lustre_quota_info *lqi)
360 {
361         int i, rc = 0;
362         ENTRY;
363
364         for (i = 0; i < 30000; i++) {
365                 rc = write_check_dquot(lqi);
366                 if (rc) {
367                         CERROR("write/check dquot failed at %d! (rc:%d)\n",
368                                i, rc);
369                         break;
370                 }
371         }
372         print_quota_info(lqi);
373         RETURN(rc);
374 }
375
376 static int quotfmt_run_tests(struct obd_device *obd, struct obd_device *tgt)
377 {
378         struct lvfs_run_ctxt saved;
379         struct lustre_quota_info *lqi = NULL;
380         int rc = 0;
381         ENTRY;
382
383         OBD_ALLOC(lqi, sizeof(*lqi));
384         if (lqi == NULL) {
385                 CERROR("not enough memory\n");
386                 RETURN(-ENOMEM);
387         }
388
389         CWARN("=== Initialize quotafile test\n");
390         rc = quotfmt_initialize(lqi, tgt, &saved);
391         if (rc)
392                 GOTO(out, rc);
393
394         CWARN("=== test  1: check quota header\n");
395         rc = quotfmt_test_1(lqi);
396         if (rc) {
397                 CERROR("check quota header failed! (rc:%d)\n", rc);
398                 GOTO(out, rc);
399         }
400
401         CWARN("=== test  2: write/read quota info\n");
402         rc = quotfmt_test_2(lqi);
403         if (rc) {
404                 CERROR("write/read quota info failed! (rc:%d)\n", rc);
405                 GOTO(out, rc);
406         }
407
408         CWARN("=== test  3: write/remove dquot\n");
409         rc = quotfmt_test_3(lqi);
410         if (rc) {
411                 CERROR("write/remove dquot failed! (rc:%d)\n", rc);
412                 GOTO(out, rc);
413         }
414
415         CWARN("=== test  4: write/read 30000 dquot\n");
416         rc = quotfmt_test_4(lqi);
417         if (rc) {
418                 CERROR("write/read 30000 dquot failed\n");
419                 GOTO(out, rc);
420         }
421
422 out:
423         CWARN("=== Finalize quotafile test\n");
424         rc = quotfmt_finalize(lqi, tgt, &saved);
425         OBD_FREE(lqi, sizeof(*lqi));
426         RETURN(rc);
427 }
428
429 static int quotfmt_test_cleanup(struct obd_device *obd)
430 {
431         ENTRY;
432         lprocfs_obd_cleanup(obd);
433         RETURN(0);
434 }
435
436 static int quotfmt_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
437 {
438         struct lprocfs_static_vars lvars;
439         struct obd_device *tgt;
440         int rc;
441         ENTRY;
442
443         if (lcfg->lcfg_bufcount < 1) {
444                 CERROR("requires a mds OBD name\n");
445                 RETURN(-EINVAL);
446         }
447
448         tgt = class_name2obd(lustre_cfg_string(lcfg, 1));
449         if (!tgt || !tgt->obd_attached || !tgt->obd_set_up) {
450                 CERROR("target device not attached or not set up (%s)\n",
451                        lustre_cfg_string(lcfg, 1));
452                 RETURN(-EINVAL);
453         }
454
455         rc = quotfmt_run_tests(obd, tgt);
456         if (rc)
457                 quotfmt_test_cleanup(obd);
458
459         lprocfs_quotfmt_test_init_vars(&lvars);
460         lprocfs_obd_setup(obd, lvars.obd_vars);
461
462         RETURN(rc);
463 }
464
465 static struct obd_ops quotfmt_obd_ops = {
466         .o_owner = THIS_MODULE,
467         .o_setup = quotfmt_test_setup,
468         .o_cleanup = quotfmt_test_cleanup,
469 };
470
471 #ifdef LPROCFS
472 static struct lprocfs_vars lprocfs_quotfmt_test_obd_vars[] = { {0} };
473 static struct lprocfs_vars lprocfs_quotfmt_test_module_vars[] = { {0} };
474
475 void lprocfs_quotfmt_test_init_vars(struct lprocfs_static_vars *lvars)
476 {
477     lvars->module_vars  = lprocfs_quotfmt_test_module_vars;
478     lvars->obd_vars     = lprocfs_quotfmt_test_obd_vars;
479 }
480 #endif
481 static int __init quotfmt_test_init(void)
482 {
483         struct lprocfs_static_vars lvars;
484
485         lprocfs_quotfmt_test_init_vars(&lvars);
486         return class_register_type(&quotfmt_obd_ops, NULL, lvars.module_vars,
487                                    "quotfmt_test", NULL);
488 }
489
490 static void __exit quotfmt_test_exit(void)
491 {
492         class_unregister_type("quotfmt_test");
493 }
494
495 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
496 MODULE_DESCRIPTION("administrative quotafile test module");
497 MODULE_LICENSE("GPL");
498
499 module_init(quotfmt_test_init);
500 module_exit(quotfmt_test_exit);
501
502 #endif /* HAVE_QUOTA_SUPPORT */