lustre/quota/qsd_config.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) 2012, 2014, Intel Corporation.
  25  * Use is subject to license terms.
  26  *
  27  * Author: Johann Lombardi <johann.lombardi@intel.com>
  28  * Author: Niu    Yawei    <yawei.niu@intel.com>
  29  */
  30
  31 #define DEBUG_SUBSYSTEM S_LQUOTA
  32
  33 #include <obd_class.h>
  34 #include <uapi/linux/lustre/lustre_param.h>
  35
  36 #include "qsd_internal.h"
  37
  38 static struct list_head qfs_list = LIST_HEAD_INIT(qfs_list);
  39 /* protect the qfs_list */
  40 static DEFINE_SPINLOCK(qfs_list_lock);
  41
  42 /*
  43  * Put reference of qsd_fsinfo.
  44  *
  45  * \param  qfs    - the qsd_fsinfo to be put
  46  */
  47 void qsd_put_fsinfo(struct qsd_fsinfo *qfs)
  48 {
  49         ENTRY;
  50         LASSERT(qfs != NULL);
  51
  52         spin_lock(&qfs_list_lock);
  53         LASSERT(qfs->qfs_ref > 0);
  54         qfs->qfs_ref--;
  55         if (qfs->qfs_ref == 0) {
  56                 LASSERT(list_empty(&qfs->qfs_qsd_list));
  57                 list_del(&qfs->qfs_link);
  58                 OBD_FREE_PTR(qfs);
  59         }
  60         spin_unlock(&qfs_list_lock);
  61         EXIT;
  62 }
  63
  64 /*
  65  * Find or create a qsd_fsinfo
  66  *
  67  * \param  name   - filesystem name
  68  * \param  create - when @create is non-zero, create new one if fail to
  69  *                  find existing qfs by @name
  70  *
  71  * \retval qsd_fsinfo - success
  72  * \retval NULL          - failure
  73  */
  74 struct qsd_fsinfo *qsd_get_fsinfo(char *name, bool create)
  75 {
  76         struct qsd_fsinfo       *qfs, *new = NULL;
  77         ENTRY;
  78
  79         if (name == NULL ||  strlen(name) >= MTI_NAME_MAXLEN)
  80                 RETURN(NULL);
  81
  82         if (create) {
  83                 /* pre-allocate a qsd_fsinfo in case there isn't one already.
  84                  * we can afford the extra cost since qsd_get_fsinfo() isn't
  85                  * called very often with create = true */
  86
  87                 OBD_ALLOC_PTR(new);
  88                 if (new == NULL)
  89                         RETURN(NULL);
  90
  91                 mutex_init(&new->qfs_mutex);
  92                 INIT_LIST_HEAD(&new->qfs_qsd_list);
  93                 strcpy(new->qfs_name, name);
  94                 new->qfs_ref = 1;
  95         }
  96
  97         /* search in the fsinfo list */
  98         spin_lock(&qfs_list_lock);
  99         list_for_each_entry(qfs, &qfs_list, qfs_link) {
 100                 if (!strcmp(qfs->qfs_name, name)) {
 101                         qfs->qfs_ref++;
 102                         goto out;
 103                 }
 104         }
 105
 106         qfs = NULL; /* not found */
 107
 108         if (new) {
 109                 /* not found, but we were asked to create a new one */
 110                 list_add_tail(&new->qfs_link, &qfs_list);
 111                 qfs = new;
 112                 new = NULL;
 113         }
 114 out:
 115         spin_unlock(&qfs_list_lock);
 116
 117         if (new)
 118                 OBD_FREE_PTR(new);
 119         RETURN(qfs);
 120 }
 121
 122 int qsd_config(char *valstr, char *fsname, int pool)
 123 {
 124         struct qsd_fsinfo *qfs;
 125         int rc, enabled = 0;
 126         bool reint = false;
 127
 128         ENTRY;
 129         qfs = qsd_get_fsinfo(fsname, 0);
 130         if (qfs == NULL) {
 131                 CERROR("failed to find quota filesystem information for %s\n",
 132                        fsname);
 133                 RETURN(-ENOENT);
 134         }
 135
 136         if (strchr(valstr, 'u'))
 137                 enabled |= 1 << USRQUOTA;
 138         if (strchr(valstr, 'g'))
 139                 enabled |= 1 << GRPQUOTA;
 140         if (strchr(valstr, 'p'))
 141                 enabled |= 1 << PRJQUOTA;
 142
 143         mutex_lock(&qfs->qfs_mutex);
 144         if (qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] == enabled)
 145                 /* no change required */
 146                 GOTO(out, rc = 0);
 147
 148         if ((qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] & enabled) != enabled)
 149                 reint = true;
 150
 151         qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] = enabled;
 152
 153         /* trigger reintegration for all qsd */
 154         if (reint) {
 155                 struct qsd_instance     *qsd;
 156                 struct qsd_qtype_info   *qqi;
 157
 158                 list_for_each_entry(qsd, &qfs->qfs_qsd_list, qsd_link) {
 159                         bool    skip = false;
 160                         int     type;
 161
 162                         /* start reintegration only if qsd_prepare() was
 163                          * successfully called */
 164                         read_lock(&qsd->qsd_lock);
 165                         if (!qsd->qsd_prepared)
 166                                 skip = true;
 167                         read_unlock(&qsd->qsd_lock);
 168                         if (skip)
 169                                 continue;
 170
 171                         for (type = USRQUOTA; type < LL_MAXQUOTAS; type++) {
 172                                 qqi = qsd->qsd_type_array[type];
 173                                 if (qqi->qqi_acct_failed) {
 174                                         LCONSOLE_ERROR("%s: can't enable quota "
 175                                                        "enforcement since space "
 176                                                        "accounting isn't functional. "
 177                                                        "Please run tunefs.lustre "
 178                                                        "--quota on an unmounted "
 179                                                        "filesystem if not done already"
 180                                                        "\n", qsd->qsd_svname);
 181                                         continue;
 182                                 }
 183                                 qsd_start_reint_thread(qqi);
 184                         }
 185                 }
 186         }
 187 out:
 188         mutex_unlock(&qfs->qfs_mutex);
 189         qsd_put_fsinfo(qfs);
 190         RETURN(0);
 191 }
 192
 193 /*
 194  * Quota configuration handlers in charge of processing all per-filesystem quota
 195  * parameters set via conf_param.
 196  *
 197  * \param lcfg - quota configuration log to be processed
 198  */
 199 int qsd_process_config(struct lustre_cfg *lcfg)
 200 {
 201         char *fsname = lustre_cfg_string(lcfg, 0);
 202         char *cfgstr = lustre_cfg_string(lcfg, 1);
 203         char *keystr, *valstr;
 204         int pool;
 205
 206         ENTRY;
 207         CDEBUG(D_QUOTA, "processing quota parameter: fs:%s cfgstr:%s\n", fsname,
 208                cfgstr);
 209
 210         if (class_match_param(cfgstr, PARAM_QUOTA, &keystr) != 0)
 211                 RETURN(-EINVAL);
 212
 213         if (!class_match_param(keystr, QUOTA_METAPOOL_NAME, &valstr))
 214                 pool = LQUOTA_RES_MD;
 215         else if (!class_match_param(keystr, QUOTA_DATAPOOL_NAME, &valstr))
 216                 pool = LQUOTA_RES_DT;
 217         else
 218                 RETURN(-EINVAL);
 219
 220         return qsd_config(valstr, fsname, pool);
 221 }