This is a compatibility band-aid on this backport.
Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>
void set_retry_attempt(int a) { head.num_retry = a; }
void set_filepath(const filepath& fp) { path = fp; }
void set_filepath2(const filepath& fp) { path2 = fp; }
- void set_string2(const char *s) { path2.set_path(std::string_view(s), 0); }
+ void set_string2(const char *s) { path2.set_path(boost::string_view(s), 0); }
void set_caller_perms(const UserPerm& _perms) {
perms.shallow_copy(_perms);
head.caller_uid = perms.uid();
Formatter::~Formatter() { }
-Formatter *Formatter::create(std::string_view type,
- std::string_view default_type,
- std::string_view fallback)
+Formatter *Formatter::create(boost::string_view type,
+ boost::string_view default_type,
+ boost::string_view fallback)
{
std::string mytype(type);
if (mytype == "")
m_ss << " ";
}
-void JSONFormatter::print_quoted_string(std::string_view s)
+void JSONFormatter::print_quoted_string(boost::string_view s)
{
int len = escape_json_attr_len(s.data(), s.size());
char escaped[len];
m_ss << foo;
}
-void JSONFormatter::dump_string(const char *name, std::string_view s)
+void JSONFormatter::dump_string(const char *name, boost::string_view s)
{
print_name(name);
print_quoted_string(s);
m_ss << "\n";
}
-void XMLFormatter::dump_string(const char *name, std::string_view s)
+void XMLFormatter::dump_string(const char *name, boost::string_view s)
{
std::string e(name);
std::transform(e.begin(), e.end(), e.begin(),
m_ss << "\n";
}
-void XMLFormatter::dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
+void XMLFormatter::dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs)
{
std::string e(name);
std::transform(e.begin(), e.end(), e.begin(),
}
}
-std::string XMLFormatter::escape_xml_str(std::string_view str)
+std::string XMLFormatter::escape_xml_str(boost::string_view str)
{
size_t len = escape_xml_attr_len(str.data());
std::vector<char> escaped(len, '\0');
m_ss.str("");
}
-void TableFormatter::dump_string(const char *name, std::string_view s)
+void TableFormatter::dump_string(const char *name, boost::string_view s)
{
finish_pending_string();
size_t i = m_vec_index(name);
m_ss.str("");
}
-void TableFormatter::dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
+void TableFormatter::dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs)
{
finish_pending_string();
size_t i = m_vec_index(name);
#include "include/int_types.h"
#include "include/buffer_fwd.h"
+#include <boost/utility/string_view.hpp>
+
#include <deque>
#include <list>
#include <vector>
class Formatter {
public:
- static Formatter *create(std::string_view type,
- std::string_view default_type,
- std::string_view fallback);
- static Formatter *create(std::string_view type,
- std::string_view default_type) {
+ static Formatter *create(boost::string_view type,
+ boost::string_view default_type,
+ boost::string_view fallback);
+ static Formatter *create(boost::string_view type,
+ boost::string_view default_type) {
return create(type, default_type, "");
}
- static Formatter *create(std::string_view type) {
+ static Formatter *create(boost::string_view type) {
return create(type, "json-pretty", "");
}
virtual void dump_unsigned(const char *name, uint64_t u) = 0;
virtual void dump_int(const char *name, int64_t s) = 0;
virtual void dump_float(const char *name, double d) = 0;
- virtual void dump_string(const char *name, std::string_view s) = 0;
+ virtual void dump_string(const char *name, boost::string_view s) = 0;
virtual void dump_bool(const char *name, bool b)
{
dump_format_unquoted(name, "%s", (b ? "true" : "false"));
{
open_object_section(name);
}
- virtual void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
+ virtual void dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs)
{
dump_string(name, s);
}
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
int get_len() const override;
bool m_pretty;
void open_section(const char *name, bool is_array);
- void print_quoted_string(std::string_view s);
+ void print_quoted_string(boost::string_view s);
void print_name(const char *name);
void print_comma(json_formatter_stack_entry_d& entry);
void finish_pending_string();
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
int get_len() const override;
/* with attrs */
void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
- void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
+ void dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs) override;
protected:
void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
void finish_pending_string();
void print_spaces();
- static std::string escape_xml_str(std::string_view str);
+ static std::string escape_xml_str(boost::string_view str);
void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
char to_lower_underscore(char c) const;
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
- void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
+ void dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs) override;
std::ostream& dump_stream(const char *name) override;
int get_len() const override;
dump_template(name, d);
}
-void HTMLFormatter::dump_string(const char *name, std::string_view s)
+void HTMLFormatter::dump_string(const char *name, boost::string_view s)
{
dump_template(name, escape_xml_str(s.data()));
}
-void HTMLFormatter::dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
+void HTMLFormatter::dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs)
{
std::string e(name);
std::string attrs_str;
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
/* with attrs */
- void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
+ void dump_string_with_attrs(const char *name, boost::string_view s, const FormatterAttrs& attrs) override;
private:
template <typename T> void dump_template(const char *name, T arg);
* Copyright 2014 Cloudius Systems
*/
/*
- * C++2014 dependencies removed. Uses of std::string_view adapted to
+ * C++2014 dependencies removed. Uses of boost::string_view adapted to
* boost::string_ref. Matt Benjamin <mbenjamin@redhat.com>
*/
#include <deque>
#include <vector>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <tuple>
#include <boost/optional/optional_io.hpp>
#include <boost/tuple/tuple.hpp>
// string
-inline void encode(std::string_view s, bufferlist& bl, uint64_t features=0)
+inline void encode(boost::string_view s, bufferlist& bl, uint64_t features=0)
{
__u32 len = s.length();
encode(len, bl);
}
inline void encode(const std::string& s, bufferlist& bl, uint64_t features=0)
{
- return encode(std::string_view(s), bl, features);
+ return encode(boost::string_view(s), bl, features);
}
inline void decode(std::string& s, bufferlist::iterator& p)
{
p.copy(len, s);
}
-inline void encode_nohead(std::string_view s, bufferlist& bl)
+inline void encode_nohead(boost::string_view s, bufferlist& bl)
{
bl.append(s.data(), s.length());
}
inline void encode_nohead(const std::string& s, bufferlist& bl)
{
- encode_nohead(std::string_view(s), bl);
+ encode_nohead(boost::string_view(s), bl);
}
inline void decode_nohead(int len, std::string& s, bufferlist::iterator& p)
{
// const char* (encode only, string compatible)
inline void encode(const char *s, bufferlist& bl)
{
- encode(std::string_view(s, strlen(s)), bl);
+ encode(boost::string_view(s, strlen(s)), bl);
}
#include <iosfwd>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <vector>
using namespace std;
public:
filepath() : ino(0), encoded(false) { }
- filepath(std::string_view s, inodeno_t i) : ino(i), path(s), encoded(false) { }
+ filepath(boost::string_view s, inodeno_t i) : ino(i), path(s), encoded(false) { }
filepath(const string& s, inodeno_t i) : ino(i), path(s), encoded(false) { }
filepath(const char* s, inodeno_t i) : ino(i), path(s), encoded(false) { }
filepath(const filepath& o) {
* if we are fed a relative path as a string, either set ino=0 (strictly
* relative) or 1 (absolute). throw out any leading '/'.
*/
- filepath(std::string_view s) : encoded(false) {
+ filepath(boost::string_view s) : encoded(false) {
set_path(s);
}
filepath(const char *s) : encoded(false) {
- set_path(std::string_view(s));
+ set_path(boost::string_view(s));
}
- void set_path(std::string_view s, inodeno_t b) {
+ void set_path(boost::string_view s, inodeno_t b) {
path = s;
ino = b;
}
- void set_path(std::string_view s) {
+ void set_path(boost::string_view s) {
if (s[0] == '/') {
path = s.substr(1);
ino = 1;
bits.pop_back();
rebuild_path();
}
- void push_dentry(std::string_view s) {
+ void push_dentry(boost::string_view s) {
if (bits.empty() && path.length() > 0)
parse_bits();
if (!bits.empty())
bits.emplace_back(s);
}
void push_dentry(const string& s) {
- push_dentry(std::string_view(s));
+ push_dentry(boost::string_view(s));
}
void push_dentry(const char *cs) {
- push_dentry(std::string_view(cs, strlen(cs)));
+ push_dentry(boost::string_view(cs, strlen(cs)));
}
void push_front_dentry(const string& s) {
bits.insert(bits.begin(), s);
#define dout_prefix *_dout << "mds.beacon." << name << ' '
-Beacon::Beacon(CephContext *cct_, MonClient *monc_, std::string_view name_) :
+Beacon::Beacon(CephContext *cct_, MonClient *monc_, boost::string_view name_) :
Dispatcher(cct_), lock("Beacon"), monc(monc_), timer(g_ceph_context, lock),
name(name_), standby_for_rank(MDS_RANK_NONE),
standby_for_fscid(FS_CLUSTER_ID_NONE), want_state(MDSMap::STATE_BOOT),
#ifndef BEACON_STATE_H
#define BEACON_STATE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "include/types.h"
#include "include/Context.h"
class Beacon : public Dispatcher
{
public:
- Beacon(CephContext *cct_, MonClient *monc_, std::string_view name);
+ Beacon(CephContext *cct_, MonClient *monc_, boost::string_view name);
~Beacon() override;
void init(MDSMap const *mdsmap);
#define CEPH_CDENTRY_H
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <set>
#include "include/counter.h"
static const unsigned EXPORT_NONCE = 1;
- CDentry(std::string_view n, __u32 h,
+ CDentry(boost::string_view n, __u32 h,
snapid_t f, snapid_t l) :
hash(h),
first(f), last(l),
versionlock(this, &versionlock_type),
name(n)
{}
- CDentry(std::string_view n, __u32 h, inodeno_t ino, unsigned char dt,
+ CDentry(boost::string_view n, __u32 h, inodeno_t ino, unsigned char dt,
snapid_t f, snapid_t l) :
hash(h),
first(f), last(l),
const CDir *get_dir() const { return dir; }
CDir *get_dir() { return dir; }
- std::string_view get_name() const { return std::string_view(name); }
+ boost::string_view get_name() const { return boost::string_view(name); }
__u32 get_hash() const { return hash; }
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "include/types.h"
return good;
}
-CDentry *CDir::lookup(std::string_view name, snapid_t snap)
+CDentry *CDir::lookup(boost::string_view name, snapid_t snap)
{
dout(20) << "lookup (" << snap << ", '" << name << "')" << dendl;
auto iter = items.lower_bound(dentry_key_t(snap, name, inode->hash_dentry_name(name)));
return 0;
}
-CDentry *CDir::lookup_exact_snap(std::string_view name, snapid_t last) {
+CDentry *CDir::lookup_exact_snap(boost::string_view name, snapid_t last) {
auto p = items.find(dentry_key_t(last, name, inode->hash_dentry_name(name)));
if (p == items.end())
return NULL;
* linking fun
*/
-CDentry* CDir::add_null_dentry(std::string_view dname,
+CDentry* CDir::add_null_dentry(boost::string_view dname,
snapid_t first, snapid_t last)
{
// foreign
}
-CDentry* CDir::add_primary_dentry(std::string_view dname, CInode *in,
+CDentry* CDir::add_primary_dentry(boost::string_view dname, CInode *in,
snapid_t first, snapid_t last)
{
// primary
return dn;
}
-CDentry* CDir::add_remote_dentry(std::string_view dname, inodeno_t ino, unsigned char d_type,
+CDentry* CDir::add_remote_dentry(boost::string_view dname, inodeno_t ino, unsigned char d_type,
snapid_t first, snapid_t last)
{
// foreign
bloom->insert(dn->get_name().data(), dn->get_name().size());
}
-bool CDir::is_in_bloom(std::string_view name)
+bool CDir::is_in_bloom(boost::string_view name)
{
if (!bloom)
return false;
* WAITING
*/
-void CDir::add_dentry_waiter(std::string_view dname, snapid_t snapid, MDSInternalContextBase *c)
+void CDir::add_dentry_waiter(boost::string_view dname, snapid_t snapid, MDSInternalContextBase *c)
{
if (waiting_on_dentry.empty())
get(PIN_DNWAITER);
<< " " << c << " on " << *this << dendl;
}
-void CDir::take_dentry_waiting(std::string_view dname, snapid_t first, snapid_t last,
+void CDir::take_dentry_waiting(boost::string_view dname, snapid_t first, snapid_t last,
list<MDSInternalContextBase*>& ls)
{
if (waiting_on_dentry.empty())
return fetch(c, want, ignore_authpinnability);
}
-void CDir::fetch(MDSInternalContextBase *c, std::string_view want_dn, bool ignore_authpinnability)
+void CDir::fetch(MDSInternalContextBase *c, boost::string_view want_dn, bool ignore_authpinnability)
{
dout(10) << "fetch on " << *this << dendl;
}
CDentry *CDir::_load_dentry(
- std::string_view key,
- std::string_view dname,
+ boost::string_view key,
+ boost::string_view dname,
const snapid_t last,
bufferlist &bl,
const int pos,
finish_waiting(WAIT_COMPLETE, -EIO);
}
-void CDir::go_bad_dentry(snapid_t last, std::string_view dname)
+void CDir::go_bad_dentry(snapid_t last, boost::string_view dname)
{
dout(10) << __func__ << " " << dname << dendl;
std::string path(get_path());
#include <map>
#include <set>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/DecayCounter.h"
#include "common/bloom_filter.hpp"
// -- dentries and inodes --
public:
- CDentry* lookup_exact_snap(std::string_view dname, snapid_t last);
- CDentry* lookup(std::string_view n, snapid_t snap=CEPH_NOSNAP);
+ CDentry* lookup_exact_snap(boost::string_view dname, snapid_t last);
+ CDentry* lookup(boost::string_view n, snapid_t snap=CEPH_NOSNAP);
CDentry* lookup(const char *n, snapid_t snap=CEPH_NOSNAP) {
- return lookup(std::string_view(n), snap);
+ return lookup(boost::string_view(n), snap);
}
- CDentry* add_null_dentry(std::string_view dname,
+ CDentry* add_null_dentry(boost::string_view dname,
snapid_t first=2, snapid_t last=CEPH_NOSNAP);
- CDentry* add_primary_dentry(std::string_view dname, CInode *in,
+ CDentry* add_primary_dentry(boost::string_view dname, CInode *in,
snapid_t first=2, snapid_t last=CEPH_NOSNAP);
- CDentry* add_remote_dentry(std::string_view dname, inodeno_t ino, unsigned char d_type,
+ CDentry* add_remote_dentry(boost::string_view dname, inodeno_t ino, unsigned char d_type,
snapid_t first=2, snapid_t last=CEPH_NOSNAP);
void remove_dentry( CDentry *dn ); // delete dentry
void link_remote_inode( CDentry *dn, inodeno_t ino, unsigned char d_type);
void try_remove_unlinked_dn(CDentry *dn);
void add_to_bloom(CDentry *dn);
- bool is_in_bloom(std::string_view name);
+ bool is_in_bloom(boost::string_view name);
bool has_bloom() { return (bloom ? true : false); }
void remove_bloom() {
bloom.reset();
return file_object_t(ino(), frag);
}
void fetch(MDSInternalContextBase *c, bool ignore_authpinnability=false);
- void fetch(MDSInternalContextBase *c, std::string_view want_dn, bool ignore_authpinnability=false);
+ void fetch(MDSInternalContextBase *c, boost::string_view want_dn, bool ignore_authpinnability=false);
void fetch(MDSInternalContextBase *c, const std::set<dentry_key_t>& keys);
protected:
mempool::mds_co::compact_set<mempool::mds_co::string> wanted_items;
bufferlist& hdrbl, std::map<std::string, bufferlist>& omap,
MDSInternalContextBase *fin);
CDentry *_load_dentry(
- std::string_view key,
- std::string_view dname,
+ boost::string_view key,
+ boost::string_view dname,
snapid_t last,
bufferlist &bl,
int pos,
/**
* Go bad due to a damaged dentry (register with damagetable and go BADFRAG)
*/
- void go_bad_dentry(snapid_t last, std::string_view dname);
+ void go_bad_dentry(snapid_t last, boost::string_view dname);
/**
* Go bad due to a damaged header (register with damagetable and go BADFRAG)
mempool::mds_co::compact_map< string_snap_t, mempool::mds_co::list<MDSInternalContextBase*> > waiting_on_dentry; // FIXME string_snap_t not in mempool
public:
- bool is_waiting_for_dentry(std::string_view dname, snapid_t snap) {
+ bool is_waiting_for_dentry(boost::string_view dname, snapid_t snap) {
return waiting_on_dentry.count(string_snap_t(dname, snap));
}
- void add_dentry_waiter(std::string_view dentry, snapid_t snap, MDSInternalContextBase *c);
- void take_dentry_waiting(std::string_view dentry, snapid_t first, snapid_t last, std::list<MDSInternalContextBase*>& ls);
+ void add_dentry_waiter(boost::string_view dentry, snapid_t snap, MDSInternalContextBase *c);
+ void take_dentry_waiting(boost::string_view dentry, snapid_t first, snapid_t last, std::list<MDSInternalContextBase*>& ls);
void take_sub_waiting(std::list<MDSInternalContextBase*>& ls); // dentry or ino
void add_waiter(uint64_t mask, MDSInternalContextBase *c) override;
// dirfrags
-__u32 InodeStoreBase::hash_dentry_name(std::string_view dn)
+__u32 InodeStoreBase::hash_dentry_name(boost::string_view dn)
{
int which = inode.dir_layout.dl_dir_hash;
if (!which)
return ceph_str_hash(which, dn.data(), dn.length());
}
-frag_t InodeStoreBase::pick_dirfrag(std::string_view dn)
+frag_t InodeStoreBase::pick_dirfrag(boost::string_view dn)
{
if (dirfragtree.empty())
return frag_t(); // avoid the string hash if we can.
if (is_symlink()) {
std::string tmp;
decode(tmp, bl);
- symlink = std::string_view(tmp);
+ symlink = boost::string_view(tmp);
}
::decode(dirfragtree, bl);
::decode(xattrs, bl);
{
std::string tmp;
::decode(tmp, p);
- symlink = std::string_view(tmp);
+ symlink = boost::string_view(tmp);
}
::decode(dirfragtree, p);
::decode(xattrs, p);
/**
* Fetch backtrace and set tag if tag is non-empty
*/
- void fetch_backtrace_and_tag(CInode *in, std::string_view tag,
+ void fetch_backtrace_and_tag(CInode *in, boost::string_view tag,
Context *fin, int *bt_r, bufferlist *bt)
{
const int64_t pool = in->get_backtrace_pool();
// present)
if (in->scrub_infop) {
// I'm a non-orphan, so look up my ScrubHeader via my linkage
- std::string_view tag = in->scrub_infop->header->get_tag();
+ boost::string_view tag = in->scrub_infop->header->get_tag();
// Rather than using the usual CInode::fetch_backtrace,
// use a special variant that optionally writes a tag in the same
// operation.
#include <list>
#include <map>
#include <set>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/config.h"
#include "include/counter.h"
void dump(Formatter *f) const;
/* For use by offline tools */
- __u32 hash_dentry_name(std::string_view dn);
- frag_t pick_dirfrag(std::string_view dn);
+ __u32 hash_dentry_name(boost::string_view dn);
+ frag_t pick_dirfrag(boost::string_view dn);
};
class InodeStore : public InodeStoreBase {
ls.back()->_wanted = 14;
ls.back()->_pending = 15;
{
- auto &r = ls.back()->_revokes.emplace_back();
+ ls.back()->_revokes.emplace_back();
+ auto &r = ls.back()->_revokes.back();
r.before = 16;
r.seq = 17;
r.last_issue = 18;
}
{
- auto &r = ls.back()->_revokes.emplace_back();
+ ls.back()->_revokes.emplace_back();
+ auto &r = ls.back()->_revokes.back();
r.before = 19;
r.seq = 20;
r.last_issue = 21;
DentryDamage(
inodeno_t ino_,
frag_t frag_,
- std::string_view dname_,
+ boost::string_view dname_,
snapid_t snap_id_)
: ino(ino_), frag(frag_), dname(dname_), snap_id(snap_id_)
{}
bool DamageTable::notify_dentry(
inodeno_t ino, frag_t frag,
- snapid_t snap_id, std::string_view dname, std::string_view path)
+ snapid_t snap_id, boost::string_view dname, boost::string_view path)
{
if (oversized()) {
return true;
}
bool DamageTable::notify_dirfrag(inodeno_t ino, frag_t frag,
- std::string_view path)
+ boost::string_view path)
{
// Special cases: damage to these dirfrags is considered fatal to
// the MDS rank that owns them.
return false;
}
-bool DamageTable::notify_remote_damaged(inodeno_t ino, std::string_view path)
+bool DamageTable::notify_remote_damaged(inodeno_t ino, boost::string_view path)
{
if (oversized()) {
return true;
bool DamageTable::is_dentry_damaged(
const CDir *dir_frag,
- std::string_view dname,
+ boost::string_view dname,
const snapid_t snap_id) const
{
if (dentries.count(
#ifndef DAMAGE_TABLE_H_
#define DAMAGE_TABLE_H_
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mdstypes.h"
#include "auth/Crypto.h"
}
}
- DentryIdent(std::string_view dname_, snapid_t snap_id_)
+ DentryIdent(boost::string_view dname_, snapid_t snap_id_)
: dname(dname_), snap_id(snap_id_)
{}
};
*
* @return true if fatal
*/
- bool notify_dirfrag(inodeno_t ino, frag_t frag, std::string_view path);
+ bool notify_dirfrag(inodeno_t ino, frag_t frag, boost::string_view path);
/**
* Indicate that a particular dentry cannot be loaded.
*/
bool notify_dentry(
inodeno_t ino, frag_t frag,
- snapid_t snap_id, std::string_view dname, std::string_view path);
+ snapid_t snap_id, boost::string_view dname, boost::string_view path);
/**
* Indicate that a particular Inode could not be loaded by number
*/
bool notify_remote_damaged(
- inodeno_t ino, std::string_view path);
+ inodeno_t ino, boost::string_view path);
bool is_dentry_damaged(
const CDir *dir_frag,
- std::string_view dname,
+ boost::string_view dname,
const snapid_t snap_id) const;
bool is_dirfrag_damaged(
}
-void FSMap::create_filesystem(std::string_view name,
+void FSMap::create_filesystem(boost::string_view name,
int64_t metadata_pool, int64_t data_pool,
uint64_t features)
{
}
int FSMap::parse_filesystem(
- std::string_view ns_str,
+ boost::string_view ns_str,
std::shared_ptr<const Filesystem> *result
) const
{
mds_map.print(out);
}
-mds_gid_t FSMap::find_standby_for(mds_role_t role, std::string_view name) const
+mds_gid_t FSMap::find_standby_for(mds_role_t role, boost::string_view name) const
{
mds_gid_t result = MDS_GID_NONE;
return MDS_GID_NONE;
}
-mds_gid_t FSMap::find_replacement_for(mds_role_t role, std::string_view name,
+mds_gid_t FSMap::find_replacement_for(mds_role_t role, boost::string_view name,
bool force_standby_active) const {
const mds_gid_t standby = find_standby_for(role, name);
if (standby)
* if legacy_client_ns is set.
*/
int FSMap::parse_role(
- std::string_view role_str,
+ boost::string_view role_str,
mds_role_t *role,
std::ostream &ss) const
{
#include <map>
#include <set>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <errno.h>
/**
* Resolve daemon name to GID
*/
- mds_gid_t find_mds_gid_by_name(std::string_view s) const
+ mds_gid_t find_mds_gid_by_name(boost::string_view s) const
{
const auto info = get_mds_info();
for (const auto &p : info) {
/**
* Resolve daemon name to status
*/
- const MDSMap::mds_info_t* find_by_name(std::string_view name) const
+ const MDSMap::mds_info_t* find_by_name(boost::string_view name) const
{
std::map<mds_gid_t, MDSMap::mds_info_t> result;
for (const auto &i : standby_daemons) {
* Caller must already have validated all arguments vs. the existing
* FSMap and OSDMap contents.
*/
- void create_filesystem(std::string_view name,
+ void create_filesystem(boost::string_view name,
int64_t metadata_pool, int64_t data_pool,
uint64_t features);
bool filesystem_exists(fs_cluster_id_t fscid) const {return filesystems.count(fscid) > 0;}
std::shared_ptr<const Filesystem> get_filesystem(fs_cluster_id_t fscid) const {return std::const_pointer_cast<const Filesystem>(filesystems.at(fscid));}
std::shared_ptr<const Filesystem> get_filesystem(void) const {return std::const_pointer_cast<const Filesystem>(filesystems.begin()->second);}
- std::shared_ptr<const Filesystem> get_filesystem(std::string_view name) const
+ std::shared_ptr<const Filesystem> get_filesystem(boost::string_view name) const
{
for (const auto &i : filesystems) {
if (i.second->mds_map.fs_name == name) {
}
int parse_filesystem(
- std::string_view ns_str,
+ boost::string_view ns_str,
std::shared_ptr<const Filesystem> *result
) const;
int parse_role(
- std::string_view role_str,
+ boost::string_view role_str,
mds_role_t *role,
std::ostream &ss) const;
return false;
}
- mds_gid_t find_standby_for(mds_role_t mds, std::string_view name) const;
+ mds_gid_t find_standby_for(mds_role_t mds, boost::string_view name) const;
mds_gid_t find_unused_for(mds_role_t mds, bool force_standby_active) const;
- mds_gid_t find_replacement_for(mds_role_t mds, std::string_view name,
+ mds_gid_t find_replacement_for(mds_role_t mds, boost::string_view name,
bool force_standby_active) const;
void get_health(list<pair<health_status_t,std::string> >& summary,
#include <map>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mds/mdstypes.h"
epoch_t get_epoch() const { return epoch; }
- fs_cluster_id_t get_fs_cid(std::string_view name) const {
+ fs_cluster_id_t get_fs_cid(boost::string_view name) const {
for (auto &p : filesystems) {
if (p.second.name == name)
return p.first;
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "MDSRank.h"
#include "MDCache.h"
};
void Locker::process_request_cap_release(MDRequestRef& mdr, client_t client, const ceph_mds_request_release& item,
- std::string_view dname)
+ boost::string_view dname)
{
inodeno_t ino = (uint64_t)item.ino;
uint64_t cap_id = item.cap_id;
#ifndef CEPH_MDS_LOCKER_H
#define CEPH_MDS_LOCKER_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "include/types.h"
bool should_defer_client_cap_frozen(CInode *in);
void process_request_cap_release(MDRequestRef& mdr, client_t client, const ceph_mds_request_release& r,
- std::string_view dname);
+ boost::string_view dname);
void kick_cap_releases(MDRequestRef& mdr);
void kick_issue_caps(CInode *in, client_t client, ceph_seq_t seq);
*
* Return -1 if not found
*/
-LogEvent::EventType LogEvent::str_to_type(std::string_view str)
+LogEvent::EventType LogEvent::str_to_type(boost::string_view str)
{
return LogEvent::types.at(std::string(str));
}
virtual ~LogEvent() { }
string get_type_str() const;
- static EventType str_to_type(std::string_view str);
+ static EventType str_to_type(boost::string_view str);
EventType get_type() const { return _type; }
void set_type(EventType t) { _type = t; }
#include <iostream>
#include <sstream>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <map>
#include "MDCache.h"
return NULL;
for (unsigned i = 0; i < fp.depth(); i++) {
- std::string_view dname = fp[i];
+ boost::string_view dname = fp[i];
frag_t fg = in->pick_dirfrag(dname);
dout(20) << " " << i << " " << dname << " frag " << fg << " from " << *in << dendl;
CDir *curdir = in->get_dirfrag(fg);
return 0;
}
-int MDCache::dump_cache(std::string_view file_name)
+int MDCache::dump_cache(boost::string_view file_name)
{
return dump_cache(file_name, NULL);
}
int MDCache::dump_cache(Formatter *f)
{
- return dump_cache(std::string_view(""), f);
+ return dump_cache(boost::string_view(""), f);
}
-int MDCache::dump_cache(std::string_view dump_root, int depth, Formatter *f)
+int MDCache::dump_cache(boost::string_view dump_root, int depth, Formatter *f)
{
- return dump_cache(std::string_view(""), f, dump_root, depth);
+ return dump_cache(boost::string_view(""), f, dump_root, depth);
}
/**
* Dump the metadata cache, either to a Formatter, if
* provided, else to a plain text file.
*/
-int MDCache::dump_cache(std::string_view fn, Formatter *f,
- std::string_view dump_root, int depth)
+int MDCache::dump_cache(boost::string_view fn, Formatter *f,
+ boost::string_view dump_root, int depth)
{
int r = 0;
int fd = -1;
};
void MDCache::enqueue_scrub(
- std::string_view path,
- std::string_view tag,
+ boost::string_view path,
+ boost::string_view tag,
bool force, bool recursive, bool repair,
Formatter *f, Context *fin)
{
mds->server->respond_to_request(mdr, 0);
}
-void MDCache::flush_dentry(std::string_view path, Context *fin)
+void MDCache::flush_dentry(boost::string_view path, Context *fin)
{
if (is_readonly()) {
dout(10) << __func__ << ": read-only FS" << dendl;
#ifndef CEPH_MDCACHE_H
#define CEPH_MDCACHE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "include/types.h"
#include "include/filepath.h"
return NULL;
return in->get_dirfrag(df.frag);
}
- CDir* get_dirfrag(inodeno_t ino, std::string_view dn) {
+ CDir* get_dirfrag(inodeno_t ino, boost::string_view dn) {
CInode *in = get_inode(ino);
if (!in)
return NULL;
void discard_delayed_expire(CDir *dir);
protected:
- int dump_cache(std::string_view fn, Formatter *f,
- std::string_view dump_root = "",
+ int dump_cache(boost::string_view fn, Formatter *f,
+ boost::string_view dump_root = "",
int depth = -1);
public:
int dump_cache() { return dump_cache(NULL, NULL); }
- int dump_cache(std::string_view filename);
+ int dump_cache(boost::string_view filename);
int dump_cache(Formatter *f);
- int dump_cache(std::string_view dump_root, int depth, Formatter *f);
+ int dump_cache(boost::string_view dump_root, int depth, Formatter *f);
int cache_status(Formatter *f);
void repair_dirfrag_stats_work(MDRequestRef& mdr);
friend class C_MDC_RepairDirfragStats;
public:
- void flush_dentry(std::string_view path, Context *fin);
+ void flush_dentry(boost::string_view path, Context *fin);
/**
* Create and start an OP_ENQUEUE_SCRUB
*/
- void enqueue_scrub(std::string_view path, std::string_view tag,
+ void enqueue_scrub(boost::string_view path, boost::string_view tag,
bool force, bool recursive, bool repair,
Formatter *f, Context *fin);
void repair_inode_stats(CInode *diri);
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <errno.h>
#include <fcntl.h>
// drop ..
}
-bool MDSCapMatch::match(std::string_view target_path,
+bool MDSCapMatch::match(boost::string_view target_path,
const int caller_uid,
const int caller_gid,
const vector<uint64_t> *caller_gid_list) const
return true;
}
-bool MDSCapMatch::match_path(std::string_view target_path) const
+bool MDSCapMatch::match_path(boost::string_view target_path) const
{
if (path.length()) {
if (target_path.find(path) != 0)
* Is the client *potentially* able to access this path? Actual
* permission will depend on uids/modes in the full is_capable.
*/
-bool MDSAuthCaps::path_capable(std::string_view inode_path) const
+bool MDSAuthCaps::path_capable(boost::string_view inode_path) const
{
for (const auto &i : grants) {
if (i.match.match_path(inode_path)) {
* This is true if any of the 'grant' clauses in the capability match the
* requested path + op.
*/
-bool MDSAuthCaps::is_capable(std::string_view inode_path,
+bool MDSAuthCaps::is_capable(boost::string_view inode_path,
uid_t inode_uid, gid_t inode_gid,
unsigned inode_mode,
uid_t caller_uid, gid_t caller_gid,
MDSCapMatch()));
}
-bool MDSAuthCaps::parse(CephContext *c, std::string_view str, ostream *err)
+bool MDSAuthCaps::parse(CephContext *c, boost::string_view str, ostream *err)
{
// Special case for legacy caps
if (str == "allow") {
#include <sstream>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <vector>
#include "include/types.h"
}
// check whether this grant matches against a given file and caller uid:gid
- bool match(std::string_view target_path,
+ bool match(boost::string_view target_path,
const int caller_uid,
const int caller_gid,
const vector<uint64_t> *caller_gid_list) const;
*
* @param target_path filesystem path without leading '/'
*/
- bool match_path(std::string_view target_path) const;
+ bool match_path(boost::string_view target_path) const;
};
struct MDSCapGrant {
: cct(NULL), grants(grants_) { }
void set_allow_all();
- bool parse(CephContext *cct, std::string_view str, std::ostream *err);
+ bool parse(CephContext *cct, boost::string_view str, std::ostream *err);
bool allow_all() const;
- bool is_capable(std::string_view inode_path,
+ bool is_capable(boost::string_view inode_path,
uid_t inode_uid, gid_t inode_gid, unsigned inode_mode,
uid_t uid, gid_t gid, const vector<uint64_t> *caller_gid_list,
unsigned mask, uid_t new_uid, gid_t new_gid) const;
- bool path_capable(std::string_view inode_path) const;
+ bool path_capable(boost::string_view inode_path) const;
friend std::ostream &operator<<(std::ostream &out, const MDSAuthCaps &cap);
};
#define dout_prefix *_dout << "mds." << name << ' '
// cons/des
-MDSDaemon::MDSDaemon(std::string_view n, Messenger *m, MonClient *mc) :
+MDSDaemon::MDSDaemon(boost::string_view n, Messenger *m, MonClient *mc) :
Dispatcher(m->cct),
mds_lock("MDSDaemon::mds_lock"),
stopping(false),
void MDSDaemon::send_command_reply(MCommand *m, MDSRank *mds_rank,
int r, bufferlist outbl,
- std::string_view outs)
+ boost::string_view outs)
{
Session *session = static_cast<Session *>(m->get_connection()->get_priv());
assert(session != NULL);
#ifndef CEPH_MDS_H
#define CEPH_MDS_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/LogClient.h"
#include "common/Mutex.h"
MDSRankDispatcher *mds_rank;
public:
- MDSDaemon(std::string_view n, Messenger *m, MonClient *mc);
+ MDSDaemon(boost::string_view n, Messenger *m, MonClient *mc);
~MDSDaemon() override;
int orig_argc;
const char **orig_argv;
// special message types
friend class C_MDS_Send_Command_Reply;
static void send_command_reply(MCommand *m, MDSRank* mds_rank, int r,
- bufferlist outbl, std::string_view outs);
+ bufferlist outbl, boost::string_view outs);
int _handle_command(
const cmdmap_t &cmdmap,
MCommand *m,
#include <map>
#include <set>
#include <string>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <errno.h>
void set_flag(int f) { flags |= f; }
void clear_flag(int f) { flags &= ~f; }
- std::string_view get_fs_name() const {return fs_name;}
+ boost::string_view get_fs_name() const {return fs_name;}
void set_snaps_allowed() {
set_flag(CEPH_MDSMAP_ALLOW_SNAPS);
assert(up.count(m) && mds_info.count(up.at(m)));
return mds_info.at(up.at(m));
}
- mds_gid_t find_mds_gid_by_name(std::string_view s) const {
+ mds_gid_t find_mds_gid_by_name(boost::string_view s) const {
for (std::map<mds_gid_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p) {
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/debug.h"
#include "common/errno.h"
public:
C_MDS_Send_Command_Reply(MDSRank *_mds, MCommand *_m) :
MDSInternalContext(_mds), m(_m) { m->get(); }
- void send (int r, std::string_view out_str) {
+ void send (int r, boost::string_view out_str) {
bufferlist bl;
MDSDaemon::send_command_reply(m, mds, r, bl, out_str);
m->put();
f->close_section(); //sessions
}
-void MDSRank::command_scrub_path(Formatter *f, std::string_view path, vector<string>& scrubop_vec)
+void MDSRank::command_scrub_path(Formatter *f, boost::string_view path, vector<string>& scrubop_vec)
{
bool force = false;
bool recursive = false;
}
void MDSRank::command_tag_path(Formatter *f,
- std::string_view path, std::string_view tag)
+ boost::string_view path, boost::string_view tag)
{
C_SaferCond scond;
{
scond.wait();
}
-void MDSRank::command_flush_path(Formatter *f, std::string_view path)
+void MDSRank::command_flush_path(Formatter *f, boost::string_view path)
{
C_SaferCond scond;
{
void MDSRank::command_export_dir(Formatter *f,
- std::string_view path,
+ boost::string_view path,
mds_rank_t target)
{
int r = _command_export_dir(path, target);
}
int MDSRank::_command_export_dir(
- std::string_view path,
+ boost::string_view path,
mds_rank_t target)
{
Mutex::Locker l(mds_lock);
#ifndef MDS_RANK_H_
#define MDS_RANK_H_
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/DecayCounter.h"
#include "common/LogClient.h"
protected:
void dump_clientreplay_status(Formatter *f) const;
- void command_scrub_path(Formatter *f, std::string_view path, vector<string>& scrubop_vec);
- void command_tag_path(Formatter *f, std::string_view path,
- std::string_view tag);
- void command_flush_path(Formatter *f, std::string_view path);
+ void command_scrub_path(Formatter *f, boost::string_view path, vector<string>& scrubop_vec);
+ void command_tag_path(Formatter *f, boost::string_view path,
+ boost::string_view tag);
+ void command_flush_path(Formatter *f, boost::string_view path);
void command_flush_journal(Formatter *f);
void command_get_subtrees(Formatter *f);
void command_export_dir(Formatter *f,
- std::string_view path, mds_rank_t dest);
+ boost::string_view path, mds_rank_t dest);
bool command_dirfrag_split(
cmdmap_t cmdmap,
std::ostream &ss);
cmdmap_t cmdmap,
std::ostream &ss,
Formatter *f);
- int _command_export_dir(std::string_view path, mds_rank_t dest);
+ int _command_export_dir(boost::string_view path, mds_rank_t dest);
int _command_flush_journal(std::stringstream *ss);
CDir *_command_dirfrag_get(
const cmdmap_t &cmdmap,
return 0;
}
-int Mantle::balance(std::string_view script,
+int Mantle::balance(boost::string_view script,
mds_rank_t whoami,
const std::vector<std::map<std::string, double>> &metrics,
std::map<mds_rank_t, double> &my_targets)
#ifndef CEPH_MANTLE_H
#define CEPH_MANTLE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <lua.hpp>
#include <vector>
public:
Mantle();
~Mantle() { if (L) lua_close(L); }
- int balance(std::string_view script,
+ int balance(boost::string_view script,
mds_rank_t whoami,
const std::vector <std::map<std::string, double>> &metrics,
std::map<mds_rank_t,double> &my_targets);
#ifndef SCRUB_HEADER_H_
#define SCRUB_HEADER_H_
-#include <string_view>
+#include <boost/utility/string_view.hpp>
class CInode;
*/
class ScrubHeader {
public:
- ScrubHeader(std::string_view tag_, bool force_, bool recursive_,
+ ScrubHeader(boost::string_view tag_, bool force_, bool recursive_,
bool repair_, Formatter *f_)
: tag(tag_), force(force_), recursive(recursive_), repair(repair_),
formatter(f_), origin(nullptr)
bool get_repair() const { return repair; }
bool get_force() const { return force; }
const CInode *get_origin() const { return origin; }
- std::string_view get_tag() const { return tag; }
+ boost::string_view get_tag() const { return tag; }
Formatter &get_formatter() const { return *formatter; }
bool get_repaired() const { return repaired; }
#include <list>
#include <iostream>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
using namespace std;
#include "common/config.h"
* verify that the dir exists and would own the dname.
* do not check if the dentry exists.
*/
-CDir *Server::validate_dentry_dir(MDRequestRef& mdr, CInode *diri, std::string_view dname)
+CDir *Server::validate_dentry_dir(MDRequestRef& mdr, CInode *diri, boost::string_view dname)
{
// make sure parent is a dir?
if (!diri->is_dir()) {
* prepare a null (or existing) dentry in given dir.
* wait for any dn lock.
*/
-CDentry* Server::prepare_null_dentry(MDRequestRef& mdr, CDir *dir, std::string_view dname, bool okexist)
+CDentry* Server::prepare_null_dentry(MDRequestRef& mdr, CDir *dir, boost::string_view dname, bool okexist)
{
dout(10) << "prepare_null_dentry " << dname << " in " << *dir << dendl;
assert(dir->is_auth());
}
// make a null dentry?
- std::string_view dname = refpath.last_dentry();
+ boost::string_view dname = refpath.last_dentry();
CDentry *dn;
if (mustexist) {
dn = dir->lookup(dname);
respond_to_request(mdr, -EINVAL);
return;
}
- std::string_view destname = destpath.last_dentry();
+ boost::string_view destname = destpath.last_dentry();
vector<CDentry*>& srctrace = mdr->dn[1];
vector<CDentry*>& desttrace = mdr->dn[0];
return;
}
- std::string_view snapname = req->get_filepath().last_dentry();
+ boost::string_view snapname = req->get_filepath().last_dentry();
if (mdr->client_request->get_caller_uid() < g_conf->mds_snap_min_uid || mdr->client_request->get_caller_uid() > g_conf->mds_snap_max_uid) {
dout(20) << "mksnap " << snapname << " on " << *diri << " denied to uid " << mdr->client_request->get_caller_uid() << dendl;
return;
}
- std::string_view snapname = req->get_filepath().last_dentry();
+ boost::string_view snapname = req->get_filepath().last_dentry();
if (mdr->client_request->get_caller_uid() < g_conf->mds_snap_min_uid || mdr->client_request->get_caller_uid() > g_conf->mds_snap_max_uid) {
dout(20) << "rmsnap " << snapname << " on " << *diri << " denied to uid " << mdr->client_request->get_caller_uid() << dendl;
return;
}
- std::string_view dstname = req->get_filepath().last_dentry();
- std::string_view srcname = req->get_filepath2().last_dentry();
+ boost::string_view dstname = req->get_filepath().last_dentry();
+ boost::string_view srcname = req->get_filepath2().last_dentry();
dout(10) << "renamesnap " << srcname << "->" << dstname << " on " << *diri << dendl;
if (srcname.length() == 0 || srcname[0] == '_') {
#ifndef CEPH_MDS_SERVER_H
#define CEPH_MDS_SERVER_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "MDSRank.h"
#include "Mutation.h"
bool check_fragment_space(MDRequestRef& mdr, CDir *in);
bool check_access(MDRequestRef& mdr, CInode *in, unsigned mask);
bool _check_access(Session *session, CInode *in, unsigned mask, int caller_uid, int caller_gid, int setattr_uid, int setattr_gid);
- CDir *validate_dentry_dir(MDRequestRef& mdr, CInode *diri, std::string_view dname);
+ CDir *validate_dentry_dir(MDRequestRef& mdr, CInode *diri, boost::string_view dname);
CDir *traverse_to_auth_dir(MDRequestRef& mdr, vector<CDentry*> &trace, filepath refpath);
- CDentry *prepare_null_dentry(MDRequestRef& mdr, CDir *dir, std::string_view dname, bool okexist=false);
+ CDentry *prepare_null_dentry(MDRequestRef& mdr, CDir *dir, boost::string_view dname, bool okexist=false);
CDentry *prepare_stray_dentry(MDRequestRef& mdr, CInode *in);
CInode* prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
file_layout_t *layout=NULL);
* Strict boolean parser. Allow true/false/0/1.
* Anything else is -EINVAL.
*/
- auto is_true = [](std::string_view bstr, bool *out) -> bool
+ auto is_true = [](boost::string_view bstr, bool *out) -> bool
{
assert(out != nullptr);
#ifndef CEPH_SNAPCLIENT_H
#define CEPH_SNAPCLIENT_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "MDSTableClient.h"
#include "snap.h"
void resend_queries() override {}
void handle_query_result(MMDSTableRequest *m) override {}
- void prepare_create(inodeno_t dirino, std::string_view name, utime_t stamp,
+ void prepare_create(inodeno_t dirino, boost::string_view name, utime_t stamp,
version_t *pstid, bufferlist *pbl, MDSInternalContextBase *onfinish) {
bufferlist bl;
__u32 op = TABLE_OP_CREATE;
_prepare(bl, pstid, pbl, onfinish);
}
- void prepare_update(inodeno_t ino, snapid_t snapid, std::string_view name, utime_t stamp,
+ void prepare_update(inodeno_t ino, snapid_t snapid, boost::string_view name, utime_t stamp,
version_t *pstid, bufferlist *pbl, MDSInternalContextBase *onfinish) {
bufferlist bl;
__u32 op = TABLE_OP_UPDATE;
#include "MDCache.h"
#include "MDSRank.h"
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "messages/MClientSnap.h"
parent->get_snap_info(infomap, MAX(first, srnode.current_parent_since), last);
}
-std::string_view SnapRealm::get_snapname(snapid_t snapid, inodeno_t atino)
+boost::string_view SnapRealm::get_snapname(snapid_t snapid, inodeno_t atino)
{
auto srnode_snaps_entry = srnode.snaps.find(snapid);
if (srnode_snaps_entry != srnode.snaps.end()) {
return parent->get_snapname(snapid, atino);
}
-snapid_t SnapRealm::resolve_snapname(std::string_view n, inodeno_t atino, snapid_t first, snapid_t last)
+snapid_t SnapRealm::resolve_snapname(boost::string_view n, inodeno_t atino, snapid_t first, snapid_t last)
{
// first try me
dout(10) << "resolve_snapname '" << n << "' in [" << first << "," << last << "]" << dendl;
#ifndef CEPH_MDS_SNAPREALM_H
#define CEPH_MDS_SNAPREALM_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mdstypes.h"
#include "snap.h"
inodes_with_caps(0)
{ }
- bool exists(std::string_view name) const {
+ bool exists(boost::string_view name) const {
for (map<snapid_t,SnapInfo>::const_iterator p = srnode.snaps.begin();
p != srnode.snaps.end();
++p) {
const bufferlist& get_snap_trace();
void build_snap_trace(bufferlist& snapbl) const;
- std::string_view get_snapname(snapid_t snapid, inodeno_t atino);
- snapid_t resolve_snapname(std::string_view name, inodeno_t atino, snapid_t first=0, snapid_t last=CEPH_NOSNAP);
+ boost::string_view get_snapname(snapid_t snapid, inodeno_t atino);
+ snapid_t resolve_snapname(boost::string_view name, inodeno_t atino, snapid_t first=0, snapid_t last=CEPH_NOSNAP);
const set<snapid_t>& get_snaps() const;
const SnapContext& get_snap_context() const;
#ifndef CEPH_MDS_EMETABLOB_H
#define CEPH_MDS_EMETABLOB_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include <stdlib.h>
fullbit(const fullbit& o);
const fullbit& operator=(const fullbit& o);
- fullbit(std::string_view d, snapid_t df, snapid_t dl,
+ fullbit(boost::string_view d, snapid_t df, snapid_t dl,
version_t v, const CInode::mempool_inode& i, const fragtree_t &dft,
- const CInode::mempool_xattr_map &xa, std::string_view sym,
+ const CInode::mempool_xattr_map &xa, boost::string_view sym,
snapid_t os, const bufferlist &sbl, __u8 st,
const CInode::mempool_old_inode_map *oi = NULL) :
dn(d), dnfirst(df), dnlast(dl), dnv(v), inode(i), xattrs(xa),
unsigned char d_type;
bool dirty;
- remotebit(std::string_view d, snapid_t df, snapid_t dl, version_t v, inodeno_t i, unsigned char dt, bool dr) :
+ remotebit(boost::string_view d, snapid_t df, snapid_t dl, version_t v, inodeno_t i, unsigned char dt, bool dr) :
dn(d), dnfirst(df), dnlast(dl), dnv(v), ino(i), d_type(dt), dirty(dr) { }
explicit remotebit(bufferlist::iterator &p) { decode(p); }
remotebit(): dnfirst(0), dnlast(0), dnv(0), ino(0),
version_t dnv;
bool dirty;
- nullbit(std::string_view d, snapid_t df, snapid_t dl, version_t v, bool dr) :
+ nullbit(boost::string_view d, snapid_t df, snapid_t dl, version_t v, bool dr) :
dn(d), dnfirst(df), dnlast(dl), dnv(v), dirty(dr) { }
explicit nullbit(bufferlist::iterator &p) { decode(p); }
nullbit(): dnfirst(0), dnlast(0), dnv(0), dirty(false) {}
#ifndef CEPH_INODE_BACKTRACE_H
#define CEPH_INODE_BACKTRACE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mdstypes.h"
version_t version; // child's version at time of backpointer creation
inode_backpointer_t() : version(0) {}
- inode_backpointer_t(inodeno_t i, std::string_view d, version_t v) : dirino(i), dname(d), version(v) {}
+ inode_backpointer_t(inodeno_t i, boost::string_view d, version_t v) : dirino(i), dname(d), version(v) {}
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator &bl);
for (list<ceph::shared_ptr<fullbit> >::const_iterator
iter = fb_list.begin(); iter != fb_list.end(); ++iter) {
- std::string_view dentry = (*iter)->dn;
+ boost::string_view dentry = (*iter)->dn;
children[dir_ino].emplace_back(dentry);
ino_locations[(*iter)->inode.ino] = Location(dir_ino, dentry);
}
for (list<nullbit>::const_iterator
iter = nb_list.begin(); iter != nb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ boost::string_view dentry = iter->dn;
children[dir_ino].emplace_back(dentry);
}
for (list<remotebit>::const_iterator
iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ boost::string_view dentry = iter->dn;
children[dir_ino].emplace_back(dentry);
}
}
list<nullbit> const &nb_list = dl.get_dnull();
for (list<nullbit>::const_iterator
iter = nb_list.begin(); iter != nb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ boost::string_view dentry = iter->dn;
leaf_locations.push_back(Location(dir_ino, dentry));
}
list<remotebit> const &rb_list = dl.get_dremote();
for (list<remotebit>::const_iterator
iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ boost::string_view dentry = iter->dn;
leaf_locations.push_back(Location(dir_ino, dentry));
}
}
#include <ostream>
#include <set>
#include <map>
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "common/config.h"
#include "common/Clock.h"
if (struct_v >= 12) {
std::string tmp;
::decode(tmp, p);
- stray_prior_path = std::string_view(tmp);
+ stray_prior_path = boost::string_view(tmp);
}
if (struct_v >= 13) {
struct dentry_key_t {
snapid_t snapid = 0;
- std::string_view name;
+ boost::string_view name;
__u32 hash = 0;
dentry_key_t() {}
- dentry_key_t(snapid_t s, std::string_view n, __u32 h=0) :
+ dentry_key_t(snapid_t s, boost::string_view n, __u32 h=0) :
snapid(s), name(n), hash(h) {}
bool is_valid() { return name.length() || snapid; }
::decode(key, bl);
decode_helper(key, nm, sn);
}
- static void decode_helper(std::string_view key, string& nm, snapid_t& sn) {
+ static void decode_helper(boost::string_view key, string& nm, snapid_t& sn) {
size_t i = key.find_last_of('_');
assert(i != string::npos);
- if (key.compare(i+1, std::string_view::npos, "head") == 0) {
+ if (key.compare(i+1, boost::string_view::npos, "head") == 0) {
// name_head
sn = CEPH_NOSNAP;
} else {
sscanf(x_str.c_str(), "%llx", &x);
sn = x;
}
- nm = key.substr(0, i);
+ nm = std::string(key.substr(0, i));
}
};
string name;
snapid_t snapid;
string_snap_t() {}
- string_snap_t(std::string_view n, snapid_t s) : name(n), snapid(s) {}
+ string_snap_t(boost::string_view n, snapid_t s) : name(n), snapid(s) {}
string_snap_t(const char *n, snapid_t s) : name(n), snapid(s) {}
void encode(bufferlist& bl) const;
memset(&capinfo, 0, sizeof(capinfo));
snap_follows = 0;
}
- cap_reconnect_t(uint64_t cap_id, inodeno_t pino, std::string_view p, int w, int i,
+ cap_reconnect_t(uint64_t cap_id, inodeno_t pino, boost::string_view p, int w, int i,
inodeno_t sr, snapid_t sf, bufferlist& lb) :
path(p) {
capinfo.cap_id = cap_id;
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "snap.h"
<< "' " << sn.stamp << ")";
}
-std::string_view SnapInfo::get_long_name()
+boost::string_view SnapInfo::get_long_name()
{
if (long_name.length() == 0) {
char nm[80];
#ifndef CEPH_MDS_SNAP_H
#define CEPH_MDS_SNAP_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mdstypes.h"
#include "common/snap_types.h"
void dump(Formatter *f) const;
static void generate_test_instances(list<SnapInfo*>& ls);
- std::string_view get_long_name();
+ boost::string_view get_long_name();
};
WRITE_CLASS_ENCODER(SnapInfo)
#ifndef CEPH_MCACHEEXPIRE_H
#define CEPH_MCACHEEXPIRE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "mds/mdstypes.h"
void add_dir(dirfrag_t r, dirfrag_t df, unsigned nonce) {
realms[r].dirs[df] = nonce;
}
- void add_dentry(dirfrag_t r, dirfrag_t df, std::string_view dn, snapid_t last, unsigned nonce) {
+ void add_dentry(dirfrag_t r, dirfrag_t df, boost::string_view dn, snapid_t last, unsigned nonce) {
realms[r].dentries[df][pair<string,snapid_t>(dn,last)] = nonce;
}
#ifndef CEPH_MCLIENTLEASE_H
#define CEPH_MCLIENTLEASE_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "msg/Message.h"
h.last = sl;
h.duration_ms = 0;
}
- MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl, std::string_view d) :
+ MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl, boost::string_view d) :
Message(CEPH_MSG_CLIENT_LEASE),
dname(d) {
h.action = ac;
*
*/
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "msg/Message.h"
#include "include/filepath.h"
void set_retry_attempt(int a) { head.num_retry = a; }
void set_filepath(const filepath& fp) { path = fp; }
void set_filepath2(const filepath& fp) { path2 = fp; }
- void set_string2(const char *s) { path2.set_path(std::string_view(s), 0); }
+ void set_string2(const char *s) { path2.set_path(boost::string_view(s), 0); }
void set_caller_uid(unsigned u) { head.caller_uid = u; }
void set_caller_gid(unsigned g) { head.caller_gid = g; }
void set_gid_list(int count, const gid_t *gids) {
#ifndef CEPH_MCOMMANDREPLY_H
#define CEPH_MCOMMANDREPLY_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "msg/Message.h"
#include "MCommand.h"
: Message(MSG_COMMAND_REPLY), r(_r) {
header.tid = m->get_tid();
}
- MCommandReply(int _r, std::string_view s)
+ MCommandReply(int _r, boost::string_view s)
: Message(MSG_COMMAND_REPLY),
r(_r), rs(s) { }
private:
#ifndef CEPH_MDENTRYLINK_H
#define CEPH_MDENTRYLINK_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
class MDentryLink : public Message {
dirfrag_t subtree;
MDentryLink() :
Message(MSG_MDS_DENTRYLINK) { }
- MDentryLink(dirfrag_t r, dirfrag_t df, std::string_view n, bool p) :
+ MDentryLink(dirfrag_t r, dirfrag_t df, boost::string_view n, bool p) :
Message(MSG_MDS_DENTRYLINK),
subtree(r),
dirfrag(df),
#ifndef CEPH_MDENTRYUNLINK_H
#define CEPH_MDENTRYUNLINK_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
class MDentryUnlink : public Message {
dirfrag_t dirfrag;
MDentryUnlink() :
Message(MSG_MDS_DENTRYUNLINK) { }
- MDentryUnlink(dirfrag_t df, std::string_view n) :
+ MDentryUnlink(dirfrag_t df, boost::string_view n) :
Message(MSG_MDS_DENTRYUNLINK),
dirfrag(df),
dn(n) {}
}
// void set_flag_forward() { flag_forward = true; }
- void set_flag_error_dn(std::string_view dn) {
+ void set_flag_error_dn(boost::string_view dn) {
flag_error_dn = true;
error_dentry = dn;
}
void set_dir_auth_hint(int a) {
dir_auth_hint = a;
}
- void set_error_dentry(std::string_view dn) {
+ void set_error_dentry(boost::string_view dn) {
error_dentry = dn;
}
#ifndef CEPH_MMDSBEACON_H
#define CEPH_MMDSBEACON_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "messages/PaxosServiceMessage.h"
}
MDSHealthMetric() : type(MDS_HEALTH_NULL), sev(HEALTH_OK) {}
- MDSHealthMetric(mds_metric_t type_, health_status_t sev_, std::string_view message_)
+ MDSHealthMetric(mds_metric_t type_, health_status_t sev_, boost::string_view message_)
: type(type_), sev(sev_), message(message_) {}
};
WRITE_CLASS_ENCODER(MDSHealthMetric)
#ifndef CEPH_MMDSCACHEREJOIN_H
#define CEPH_MMDSCACHEREJOIN_H
-#include <string_view>
+#include <boost/utility/string_view.hpp>
#include "msg/Message.h"
void add_weak_dirfrag(dirfrag_t df) {
weak_dirfrags.insert(df);
}
- void add_weak_dentry(inodeno_t dirino, std::string_view dname, snapid_t last, dn_weak& dnw) {
+ void add_weak_dentry(inodeno_t dirino, boost::string_view dname, snapid_t last, dn_weak& dnw) {
weak[dirino][string_snap_t(dname, last)] = dnw;
}
- void add_weak_primary_dentry(inodeno_t dirino, std::string_view dname, snapid_t first, snapid_t last, inodeno_t ino) {
+ void add_weak_primary_dentry(inodeno_t dirino, boost::string_view dname, snapid_t first, snapid_t last, inodeno_t ino) {
weak[dirino][string_snap_t(dname, last)] = dn_weak(first, ino);
}
- void add_strong_dentry(dirfrag_t df, std::string_view dname, snapid_t first, snapid_t last, inodeno_t pi, inodeno_t ri, unsigned char rdt, int n, int ls) {
+ void add_strong_dentry(dirfrag_t df, boost::string_view dname, snapid_t first, snapid_t last, inodeno_t pi, inodeno_t ri, unsigned char rdt, int n, int ls) {
strong_dentries[df][string_snap_t(dname, last)] = dn_strong(first, pi, ri, rdt, n, ls);
}
- void add_dentry_authpin(dirfrag_t df, std::string_view dname, snapid_t last,
+ void add_dentry_authpin(dirfrag_t df, boost::string_view dname, snapid_t last,
const metareqid_t& ri, __u32 attempt) {
authpinned_dentries[df][string_snap_t(dname, last)].push_back(slave_reqid(ri, attempt));
}
- void add_dentry_xlock(dirfrag_t df, std::string_view dname, snapid_t last,
+ void add_dentry_xlock(dirfrag_t df, boost::string_view dname, snapid_t last,
const metareqid_t& ri, __u32 attempt) {
xlocked_dentries[df][string_snap_t(dname, last)] = slave_reqid(ri, attempt);
}
dump_pyobject(name, PyFloat_FromDouble(d));
}
-void PyFormatter::dump_string(const char *name, std::string_view s)
+void PyFormatter::dump_string(const char *name, boost::string_view s)
{
dump_pyobject(name, PyString_FromString(s.data()));
}
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
dump_value_int(name, "%f", d);
}
-void RGWFormatter_Plain::dump_string(const char *name, std::string_view s)
+void RGWFormatter_Plain::dump_string(const char *name, boost::string_view s)
{
dump_format(name, "%s", s.data());
}
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t u) override;
void dump_float(const char *name, double d) override;
- void dump_string(const char *name, std::string_view s) override;
+ void dump_string(const char *name, boost::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
int get_len() const override;
projects / ceph.git / commitdiff