fs/xfs/xfs_sysfs.c

   1 /*
   2  * Copyright (c) 2014 Red Hat, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "xfs.h"
  20 #include "xfs_sysfs.h"
  21 #include "xfs_log_format.h"
  22 #include "xfs_log.h"
  23 #include "xfs_log_priv.h"
  24
  25 struct xfs_sysfs_attr {
  26         struct attribute attr;
  27         ssize_t (*show)(char *buf, void *data);
  28         ssize_t (*store)(const char *buf, size_t count, void *data);
  29 };
  30
  31 static inline struct xfs_sysfs_attr *
  32 to_attr(struct attribute *attr)
  33 {
  34         return container_of(attr, struct xfs_sysfs_attr, attr);
  35 }
  36
  37 #define XFS_SYSFS_ATTR_RW(name) \
  38         static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name)
  39 #define XFS_SYSFS_ATTR_RO(name) \
  40         static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name)
  41
  42 #define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr
  43
  44 /*
  45  * xfs_mount kobject. This currently has no attributes and thus no need for show
  46  * and store helpers. The mp kobject serves as the per-mount parent object that
  47  * is identified by the fsname under sysfs.
  48  */
  49
  50 struct kobj_type xfs_mp_ktype = {
  51         .release = xfs_sysfs_release,
  52 };
  53
  54 #ifdef DEBUG
  55 /* debug */
  56
  57 STATIC ssize_t
  58 log_recovery_delay_store(
  59         const char      *buf,
  60         size_t          count,
  61         void            *data)
  62 {
  63         int             ret;
  64         int             val;
  65
  66         ret = kstrtoint(buf, 0, &val);
  67         if (ret)
  68                 return ret;
  69
  70         if (val < 0 || val > 60)
  71                 return -EINVAL;
  72
  73         xfs_globals.log_recovery_delay = val;
  74
  75         return count;
  76 }
  77
  78 STATIC ssize_t
  79 log_recovery_delay_show(
  80         char    *buf,
  81         void    *data)
  82 {
  83         return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.log_recovery_delay);
  84 }
  85 XFS_SYSFS_ATTR_RW(log_recovery_delay);
  86
  87 static struct attribute *xfs_dbg_attrs[] = {
  88         ATTR_LIST(log_recovery_delay),
  89         NULL,
  90 };
  91
  92 STATIC ssize_t
  93 xfs_dbg_show(
  94         struct kobject          *kobject,
  95         struct attribute        *attr,
  96         char                    *buf)
  97 {
  98         struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
  99
 100         return xfs_attr->show ? xfs_attr->show(buf, NULL) : 0;
 101 }
 102
 103 STATIC ssize_t
 104 xfs_dbg_store(
 105         struct kobject          *kobject,
 106         struct attribute        *attr,
 107         const char              *buf,
 108         size_t                  count)
 109 {
 110         struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
 111
 112         return xfs_attr->store ? xfs_attr->store(buf, count, NULL) : 0;
 113 }
 114
 115 static struct sysfs_ops xfs_dbg_ops = {
 116         .show = xfs_dbg_show,
 117         .store = xfs_dbg_store,
 118 };
 119
 120 struct kobj_type xfs_dbg_ktype = {
 121         .release = xfs_sysfs_release,
 122         .sysfs_ops = &xfs_dbg_ops,
 123         .default_attrs = xfs_dbg_attrs,
 124 };
 125
 126 #endif /* DEBUG */
 127
 128 /* xlog */
 129
 130 STATIC ssize_t
 131 log_head_lsn_show(
 132         char    *buf,
 133         void    *data)
 134 {
 135         struct xlog *log = data;
 136         int cycle;
 137         int block;
 138
 139         spin_lock(&log->l_icloglock);
 140         cycle = log->l_curr_cycle;
 141         block = log->l_curr_block;
 142         spin_unlock(&log->l_icloglock);
 143
 144         return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
 145 }
 146 XFS_SYSFS_ATTR_RO(log_head_lsn);
 147
 148 STATIC ssize_t
 149 log_tail_lsn_show(
 150         char    *buf,
 151         void    *data)
 152 {
 153         struct xlog *log = data;
 154         int cycle;
 155         int block;
 156
 157         xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block);
 158         return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
 159 }
 160 XFS_SYSFS_ATTR_RO(log_tail_lsn);
 161
 162 STATIC ssize_t
 163 reserve_grant_head_show(
 164         char    *buf,
 165         void    *data)
 166 {
 167         struct xlog *log = data;
 168         int cycle;
 169         int bytes;
 170
 171         xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes);
 172         return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
 173 }
 174 XFS_SYSFS_ATTR_RO(reserve_grant_head);
 175
 176 STATIC ssize_t
 177 write_grant_head_show(
 178         char    *buf,
 179         void    *data)
 180 {
 181         struct xlog *log = data;
 182         int cycle;
 183         int bytes;
 184
 185         xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes);
 186         return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
 187 }
 188 XFS_SYSFS_ATTR_RO(write_grant_head);
 189
 190 static struct attribute *xfs_log_attrs[] = {
 191         ATTR_LIST(log_head_lsn),
 192         ATTR_LIST(log_tail_lsn),
 193         ATTR_LIST(reserve_grant_head),
 194         ATTR_LIST(write_grant_head),
 195         NULL,
 196 };
 197
 198 static inline struct xlog *
 199 to_xlog(struct kobject *kobject)
 200 {
 201         struct xfs_kobj *kobj = to_kobj(kobject);
 202         return container_of(kobj, struct xlog, l_kobj);
 203 }
 204
 205 STATIC ssize_t
 206 xfs_log_show(
 207         struct kobject          *kobject,
 208         struct attribute        *attr,
 209         char                    *buf)
 210 {
 211         struct xlog *log = to_xlog(kobject);
 212         struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
 213
 214         return xfs_attr->show ? xfs_attr->show(buf, log) : 0;
 215 }
 216
 217 STATIC ssize_t
 218 xfs_log_store(
 219         struct kobject          *kobject,
 220         struct attribute        *attr,
 221         const char              *buf,
 222         size_t                  count)
 223 {
 224         struct xlog *log = to_xlog(kobject);
 225         struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
 226
 227         return xfs_attr->store ? xfs_attr->store(buf, count, log) : 0;
 228 }
 229
 230 static struct sysfs_ops xfs_log_ops = {
 231         .show = xfs_log_show,
 232         .store = xfs_log_store,
 233 };
 234
 235 struct kobj_type xfs_log_ktype = {
 236         .release = xfs_sysfs_release,
 237         .sysfs_ops = &xfs_log_ops,
 238         .default_attrs = xfs_log_attrs,
 239 };