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 /*
 123  * Quota configuration handlers in charge of processing all per-filesystem quota
 124  * parameters set via conf_param.
 125  *
 126  * \param lcfg - quota configuration log to be processed
 127  */
 128 int qsd_process_config(struct lustre_cfg *lcfg)
 129 {
 130         struct qsd_fsinfo       *qfs;
 131         char                    *fsname = lustre_cfg_string(lcfg, 0);
 132         char                    *cfgstr = lustre_cfg_string(lcfg, 1);
 133         char                    *keystr, *valstr;
 134         int                      rc, pool, enabled = 0;
 135         bool                     reint = false;
 136         ENTRY;
 137
 138         CDEBUG(D_QUOTA, "processing quota parameter: fs:%s cfgstr:%s\n", fsname,
 139                cfgstr);
 140
 141         if (class_match_param(cfgstr, PARAM_QUOTA, &keystr) != 0)
 142                 RETURN(-EINVAL);
 143
 144         if (!class_match_param(keystr, QUOTA_METAPOOL_NAME, &valstr))
 145                 pool = LQUOTA_RES_MD;
 146         else if (!class_match_param(keystr, QUOTA_DATAPOOL_NAME, &valstr))
 147                 pool = LQUOTA_RES_DT;
 148         else
 149                 RETURN(-EINVAL);
 150
 151         qfs = qsd_get_fsinfo(fsname, 0);
 152         if (qfs == NULL) {
 153                 CERROR("failed to find quota filesystem information for %s\n",
 154                        fsname);
 155                 RETURN(-ENOENT);
 156         }
 157
 158         if (strchr(valstr, 'u'))
 159                 enabled |= 1 << USRQUOTA;
 160         if (strchr(valstr, 'g'))
 161                 enabled |= 1 << GRPQUOTA;
 162         if (strchr(valstr, 'p'))
 163                 enabled |= 1 << PRJQUOTA;
 164
 165         mutex_lock(&qfs->qfs_mutex);
 166         if (qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] == enabled)
 167                 /* no change required */
 168                 GOTO(out, rc = 0);
 169
 170         if ((qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] & enabled) != enabled)
 171                 reint = true;
 172
 173         qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] = enabled;
 174
 175         /* trigger reintegration for all qsd */
 176         if (reint) {
 177                 struct qsd_instance     *qsd;
 178                 struct qsd_qtype_info   *qqi;
 179
 180                 list_for_each_entry(qsd, &qfs->qfs_qsd_list, qsd_link) {
 181                         bool    skip = false;
 182                         int     type;
 183
 184                         /* start reintegration only if qsd_prepare() was
 185                          * successfully called */
 186                         read_lock(&qsd->qsd_lock);
 187                         if (!qsd->qsd_prepared)
 188                                 skip = true;
 189                         read_unlock(&qsd->qsd_lock);
 190                         if (skip)
 191                                 continue;
 192
 193                         for (type = USRQUOTA; type < LL_MAXQUOTAS; type++) {
 194                                 qqi = qsd->qsd_type_array[type];
 195                                 if (qqi->qqi_acct_failed) {
 196                                         LCONSOLE_ERROR("%s: can't enable quota "
 197                                                        "enforcement since space "
 198                                                        "accounting isn't functional. "
 199                                                        "Please run tunefs.lustre "
 200                                                        "--quota on an unmounted "
 201                                                        "filesystem if not done already"
 202                                                        "\n", qsd->qsd_svname);
 203                                         continue;
 204                                 }
 205                                 qsd_start_reint_thread(qqi);
 206                         }
 207                 }
 208         }
 209 out:
 210         mutex_unlock(&qfs->qfs_mutex);
 211         qsd_put_fsinfo(qfs);
 212         RETURN(0);
 213 }