struct tg_export_data *ted = &exp->exp_target_data;
int level = D_CACHE;
- if (exp->exp_obd->obd_self_export == exp)
- CDEBUG(D_CACHE, "%s: processing self export: %ld %ld "
- "%ld\n", exp->exp_obd->obd_name, ted->ted_grant,
- ted->ted_pending, ted->ted_dirty);
-
if (ted->ted_grant < 0 || ted->ted_pending < 0 || ted->ted_dirty < 0)
level = D_ERROR;
CDEBUG_LIMIT(level, "%s: cli %s/%p dirty %ld pend %ld grant %ld\n",
struct lu_target *lut = obd->u.obt.obt_lut;
struct tg_grants_data *tgd = &lut->lut_tgd;
struct obd_export *exp;
+ struct tg_export_data *ted;
u64 maxsize;
u64 tot_dirty = 0;
u64 tot_pending = 0;
spin_lock(&obd->obd_dev_lock);
spin_lock(&tgd->tgd_grant_lock);
+ exp = obd->obd_self_export;
+ ted = &exp->exp_target_data;
+ CDEBUG(D_CACHE, "%s: processing self export: %ld %ld "
+ "%ld\n", obd->obd_name, ted->ted_grant,
+ ted->ted_pending, ted->ted_dirty);
+ tot_granted += ted->ted_grant + ted->ted_pending;
+ tot_pending += ted->ted_pending;
+ tot_dirty += ted->ted_dirty;
+
list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain) {
error = tgt_check_export_grants(exp, &tot_dirty, &tot_pending,
&tot_granted, maxsize);
if (unlikely(rc))
GOTO(out, rc);
+ osfs->os_namelen = min_t(__u32, osfs->os_namelen, NAME_MAX);
+
spin_lock(&tgd->tgd_grant_lock);
spin_lock(&tgd->tgd_osfs_lock);
/* calculate how much space was written while we released the
u64 left;
u64 avail;
u64 unstable;
+ u64 reserved;
ENTRY;
assert_spin_locked(&tgd->tgd_grant_lock);
unstable = tgd->tgd_osfs_unstable; /* those might be accounted twice */
spin_unlock(&tgd->tgd_osfs_lock);
- tot_granted = tgd->tgd_tot_granted;
+ reserved = left * tgd->tgd_reserved_pcnt / 100;
+ tot_granted = tgd->tgd_tot_granted + reserved;
if (left < tot_granted) {
int mask = (left + unstable <
if ((grant > chunk) && conservative)
grant = chunk;
+ /*
+ * Limit grant so that export' grant does not exceed what the
+ * client would like to have by more than grants for 2 full
+ * RPCs
+ */
+ if (ted->ted_grant + grant > want + chunk)
+ grant = want + chunk - ted->ted_grant;
+
tgd->tgd_tot_granted += grant;
ted->ted_grant += grant;
RETURN(rc);
}
EXPORT_SYMBOL(tgt_grant_commit_cb_add);
+
+/**
+ * Show estimate of total amount of dirty data on clients.
+ *
+ * \param[in] m seq_file handle
+ * \param[in] data unused for single entry
+ *
+ * \retval 0 on success
+ * \retval negative value on error
+ */
+int tgt_tot_dirty_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct tg_grants_data *tgd;
+
+ LASSERT(obd != NULL);
+ tgd = &obd->u.obt.obt_lut->lut_tgd;
+ seq_printf(m, "%llu\n", tgd->tgd_tot_dirty);
+ return 0;
+}
+EXPORT_SYMBOL(tgt_tot_dirty_seq_show);
+
+/**
+ * Show total amount of space granted to clients.
+ *
+ * \param[in] m seq_file handle
+ * \param[in] data unused for single entry
+ *
+ * \retval 0 on success
+ * \retval negative value on error
+ */
+int tgt_tot_granted_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct tg_grants_data *tgd;
+
+ LASSERT(obd != NULL);
+ tgd = &obd->u.obt.obt_lut->lut_tgd;
+ seq_printf(m, "%llu\n", tgd->tgd_tot_granted);
+ return 0;
+}
+EXPORT_SYMBOL(tgt_tot_granted_seq_show);
+
+/**
+ * Show total amount of space used by IO in progress.
+ *
+ * \param[in] m seq_file handle
+ * \param[in] data unused for single entry
+ *
+ * \retval 0 on success
+ * \retval negative value on error
+ */
+int tgt_tot_pending_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct tg_grants_data *tgd;
+
+ LASSERT(obd != NULL);
+ tgd = &obd->u.obt.obt_lut->lut_tgd;
+ seq_printf(m, "%llu\n", tgd->tgd_tot_pending);
+ return 0;
+}
+EXPORT_SYMBOL(tgt_tot_pending_seq_show);
+
+/**
+ * Show if grants compatibility mode is disabled.
+ *
+ * When tgd_grant_compat_disable is set, we don't grant any space to clients
+ * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
+ * a client is inflated since it consumes PAGE_SIZE of grant space per
+ * block, (i.e. typically 4kB units), but underlaying file system might have
+ * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
+ *
+ * \param[in] m seq_file handle
+ * \param[in] data unused for single entry
+ *
+ * \retval 0 on success
+ * \retval negative value on error
+ */
+int tgt_grant_compat_disable_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = m->private;
+ struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
+
+ seq_printf(m, "%u\n", tgd->tgd_grant_compat_disable);
+ return 0;
+}
+EXPORT_SYMBOL(tgt_grant_compat_disable_seq_show);
+
+/**
+ * Change grant compatibility mode.
+ *
+ * Setting tgd_grant_compat_disable prohibit any space granting to clients
+ * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
+ *
+ * \param[in] file proc file
+ * \param[in] buffer string which represents mode
+ * 1: disable compatibility mode
+ * 0: enable compatibility mode
+ * \param[in] count \a buffer length
+ * \param[in] off unused for single entry
+ *
+ * \retval \a count on success
+ * \retval negative number on error
+ */
+ssize_t tgt_grant_compat_disable_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
+{
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
+ struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
+ __s64 val;
+ int rc;
+
+ rc = lprocfs_str_to_s64(buffer, count, &val);
+ if (rc)
+ return rc;
+
+ if (val < 0)
+ return -EINVAL;
+
+ tgd->tgd_grant_compat_disable = !!val;
+
+ return count;
+}
+EXPORT_SYMBOL(tgt_grant_compat_disable_seq_write);