struct EntityAuth {
- __u64 auid;
+ uint64_t auid;
CryptoKey key;
map<string, bufferlist> caps;
virtual bool verify_authorizer(KeyStore *keys,
bufferlist& authorizer_data, bufferlist& authorizer_reply,
EntityName& entity_name, uint64_t& global_id,
- AuthCapsInfo& caps_info, __u64 *auid = NULL) = 0;
+ AuthCapsInfo& caps_info, uint64_t *auid = NULL) = 0;
};
extern AuthAuthorizeHandler *get_authorize_handler(int protocol);
virtual ~AuthServiceHandler() { }
virtual int start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result, AuthCapsInfo& caps) = 0;
- virtual int handle_request(bufferlist::iterator& indata, bufferlist& result, uint64_t& global_id, AuthCapsInfo& caps, __u64 *auid = NULL) = 0;
+ virtual int handle_request(bufferlist::iterator& indata, bufferlist& result, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) = 0;
EntityName& get_entity_name() { return entity_name; }
};
void set_caps(EntityName& name, map<string, bufferlist>& caps) {
keys[name].caps = caps;
}
- void set_uid(EntityName& ename, __u64 auid) {
+ void set_uid(EntityName& ename, uint64_t auid) {
keys[ename].auid = auid;
}
void import(KeyRing& other);
bool CephxAuthorizeHandler::verify_authorizer(KeyStore *keys,
bufferlist& authorizer_data, bufferlist& authorizer_reply,
- EntityName& entity_name, uint64_t& global_id, AuthCapsInfo& caps_info, __u64 *auid)
+ EntityName& entity_name, uint64_t& global_id, AuthCapsInfo& caps_info, uint64_t *auid)
{
bufferlist::iterator iter = authorizer_data.begin();
bool verify_authorizer(KeyStore *keys,
bufferlist& authorizer_data, bufferlist& authorizer_reply,
EntityName& entity_name, uint64_t& global_id,
- AuthCapsInfo& caps_info, __u64 *auid = NULL);
+ AuthCapsInfo& caps_info, uint64_t *auid = NULL);
};
-int cephx_calc_client_server_challenge(CryptoKey& secret, __u64 server_challenge, __u64 client_challenge, __u64 *key)
+int cephx_calc_client_server_challenge(CryptoKey& secret, uint64_t server_challenge, uint64_t client_challenge, uint64_t *key)
{
CephXChallengeBlob b;
b.server_challenge = server_challenge;
if (ret < 0)
return ret;
- __u64 k = 0;
+ uint64_t k = 0;
const uint64_t *p = (const uint64_t *)enc.c_str();
for (int pos = 0; pos + sizeof(k) <= enc.length(); pos+=sizeof(k), p++)
k ^= *p;
{
CephXAuthorizer *a = new CephXAuthorizer;
a->session_key = session_key;
- a->nonce = ((__u64)rand() << 32) + rand();
+ a->nonce = ((uint64_t)rand() << 32) + rand();
__u8 authorizer_v = 1;
::encode(authorizer_v, a->bl);
return false;
}
- __u64 expect = nonce + 1;
+ uint64_t expect = nonce + 1;
if (expect != reply.nonce_plus_one) {
dout(0) << "verify_authorizer_reply bad nonce got " << reply.nonce_plus_one << " expected " << expect
<< " sent " << nonce << dendl;
// initial server -> client challenge
struct CephXServerChallenge {
- __u64 server_challenge;
+ uint64_t server_challenge;
void encode(bufferlist& bl) const {
__u8 struct_v = 1;
// client -> server response to challenge
struct CephXAuthenticate {
- __u64 client_challenge;
- __u64 key;
+ uint64_t client_challenge;
+ uint64_t key;
CephXTicketBlob old_ticket;
void encode(bufferlist& bl) const {
WRITE_CLASS_ENCODER(CephXAuthenticate)
struct CephXChallengeBlob {
- __u64 server_challenge, client_challenge;
+ uint64_t server_challenge, client_challenge;
void encode(bufferlist& bl) const {
::encode(server_challenge, bl);
};
WRITE_CLASS_ENCODER(CephXChallengeBlob)
-int cephx_calc_client_server_challenge(CryptoKey& secret, __u64 server_challenge, __u64 client_challenge,
- __u64 *key);
+int cephx_calc_client_server_challenge(CryptoKey& secret, uint64_t server_challenge, uint64_t client_challenge,
+ uint64_t *key);
/*
*/
struct CephXAuthorizeReply {
- __u64 nonce_plus_one;
+ uint64_t nonce_plus_one;
void encode(bufferlist& bl) const {
__u8 struct_v = 1;
::encode(struct_v, bl);
struct CephXAuthorizer : public AuthAuthorizer {
- __u64 nonce;
+ uint64_t nonce;
CryptoKey session_key;
CephXAuthorizer() : AuthAuthorizer(CEPH_AUTH_CEPHX) {}
WRITE_CLASS_ENCODER(CephXServiceTicketInfo);
struct CephXAuthorize {
- __u64 nonce;
+ uint64_t nonce;
void encode(bufferlist& bl) const {
__u8 struct_v = 1;
::encode(struct_v, bl);
return CEPH_AUTH_CEPHX;
}
-int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, __u64 *auid)
+int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid)
{
int ret = 0;
break;
}
- __u64 expected_key;
+ uint64_t expected_key;
cephx_calc_client_server_challenge(secret, server_challenge, req.client_challenge, &expected_key);
dout(20) << " checking key: req.key=" << hex << req.key
~CephxServiceHandler() {}
int start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps);
- int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, __u64 *auid = NULL);
+ int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL);
void build_cephx_response_header(int request_type, int status, bufferlist& bl);
};
bool AuthNoneAuthorizeHandler::verify_authorizer(KeyStore *keys,
bufferlist& authorizer_data, bufferlist& authorizer_reply,
EntityName& entity_name, uint64_t& global_id, AuthCapsInfo& caps_info,
-__u64 *auid)
+uint64_t *auid)
{
bufferlist::iterator iter = authorizer_data.begin();
bool verify_authorizer(KeyStore *keys,
bufferlist& authorizer_data, bufferlist& authorizer_reply,
EntityName& entity_name, uint64_t& global_id,
- AuthCapsInfo& caps_info, __u64 *auid=NULL);
+ AuthCapsInfo& caps_info, uint64_t *auid=NULL);
};
caps.allow_all = true;
return CEPH_AUTH_NONE;
}
- int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, __u64 *auid = NULL) {
+ int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) {
assert(0); // shouldn't get called
return 0;
}
const char *caps_fn = NULL;
const char *import_keyring = NULL;
bool set_auid = false;
- __u64 auid = CEPH_AUTH_UID_DEFAULT;
+ uint64_t auid = CEPH_AUTH_UID_DEFAULT;
const char *name = g_conf.name;
FOR_EACH_ARG(args) {
void Client::update_inode_file_bits(Inode *in,
- __u64 truncate_seq, __u64 truncate_size,
- __u64 size,
- __u64 time_warp_seq, utime_t ctime,
+ uint64_t truncate_seq, uint64_t truncate_size,
+ uint64_t size,
+ uint64_t time_warp_seq, utime_t ctime,
utime_t mtime,
utime_t atime,
int issued)
}
void Client::send_cap(Inode *in, int mds, InodeCap *cap, int used, int want, int retain, int flush,
- __u64 tid)
+ uint64_t tid)
{
int held = cap->issued | cap->implemented;
int revoking = cap->implemented & ~cap->issued;
unsigned wanted = in->caps_wanted();
unsigned used = in->caps_used();
int flush = 0;
- __u64 flush_tid = 0;
+ uint64_t flush_tid = 0;
int retain = wanted | CEPH_CAP_PIN;
if (!unmounting) {
}
}
-void Client::add_update_cap(Inode *in, int mds, __u64 cap_id,
+void Client::add_update_cap(Inode *in, int mds, uint64_t cap_id,
unsigned issued, unsigned seq, unsigned mseq, inodeno_t realm,
int flags)
{
check_caps(in, true);
}
}
-void Client::wait_sync_caps(__u64 want)
+void Client::wait_sync_caps(uint64_t want)
{
retry:
dout(10) << "wait_sync_caps want " << want << " (last is " << last_flush_seq << ", "
void Client::renew_caps(const int mds) {
dout(10) << "renew_caps mds" << mds << dendl;
mds_sessions[mds].last_cap_renew_request = g_clock.now();
- __u64 seq = ++mds_sessions[mds].cap_renew_seq;
+ uint64_t seq = ++mds_sessions[mds].cap_renew_seq;
messenger->send_message(new MClientSession(CEPH_SESSION_REQUEST_RENEWCAPS, seq),
mdsmap->get_inst(mds));
return r;
}
-int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
+int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl)
{
Inode *in = f->inode;
return r;
}
-int Client::_read_async(Fh *f, __u64 off, __u64 len, bufferlist *bl)
+int Client::_read_async(Fh *f, uint64_t off, uint64_t len, bufferlist *bl)
{
Inode *in = f->inode;
bool readahead = true;
return r;
}
-int Client::_read_sync(Fh *f, __u64 off, __u64 len, bufferlist *bl)
+int Client::_read_sync(Fh *f, uint64_t off, uint64_t len, bufferlist *bl)
{
Inode *in = f->inode;
- __u64 pos = off;
+ uint64_t pos = off;
int left = len;
int read = 0;
}
-int Client::_write(Fh *f, __s64 offset, __u64 size, const char *buf)
+int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
{
- if ((__u64)(offset+size) > mdsmap->get_max_filesize()) //too large!
+ if ((uint64_t)(offset+size) > mdsmap->get_max_filesize()) //too large!
return -EFBIG;
if (osdmap->test_flag(CEPH_OSDMAP_FULL))
bufferlist bl;
bl.push_back( bp );
- __u64 endoff = offset + size;
+ uint64_t endoff = offset + size;
int got;
int r = get_caps(in, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER, &got, endoff);
if (r < 0)
client_logger->favg(l_c_wrlat,(double)lat);
// assume success for now. FIXME.
- __u64 totalwritten = size;
+ uint64_t totalwritten = size;
// extend file?
if (totalwritten + offset > in->size) {
return _sync_fs();
}
-__s64 Client::drop_caches()
+int64_t Client::drop_caches()
{
Mutex::Locker l(client_lock);
return objectcacher->release_all();
class Dentry;
struct MetaRequest {
- __u64 tid;
+ uint64_t tid;
ceph_mds_request_head head;
filepath path, path2;
bufferlist data;
struct MDSSession {
version_t seq;
- __u64 cap_gen;
+ uint64_t cap_gen;
utime_t cap_ttl, last_cap_renew_request;
- __u64 cap_renew_seq;
+ uint64_t cap_renew_seq;
int num_caps;
entity_inst_t inst;
bool closing;
int ref; // 1 if there's a dir beneath me.
int lease_mds;
utime_t lease_ttl;
- __u64 lease_gen;
+ uint64_t lease_gen;
ceph_seq_t lease_seq;
int cap_shared_gen;
public:
Inode *parent_inode; // my inode
hash_map<nstring, Dentry*> dentries;
- __u64 release_count;
+ uint64_t release_count;
Dir(Inode* in) : release_count(0) { parent_inode = in; }
Inode *inode;
xlist<InodeCap*>::item cap_item;
- __u64 cap_id;
+ uint64_t cap_id;
unsigned issued;
unsigned implemented;
unsigned wanted; // as known to mds.
- __u64 seq, issue_seq;
+ uint64_t seq, issue_seq;
__u32 mseq; // migration seq
__u32 gen;
//snapid_t follows; // map key
SnapContext context;
int issued, dirty;
- __u64 size;
+ uint64_t size;
utime_t ctime, mtime, atime;
version_t time_warp_seq;
bool writing, dirty_data;
- __u64 flush_tid;
+ uint64_t flush_tid;
CapSnap() : issued(0), dirty(0), size(0), time_warp_seq(0), writing(false), dirty_data(false), flush_tid(0) {}
};
utime_t atime; // file data access time.
uint32_t time_warp_seq; // count of (potential) mtime/atime timewarps (i.e., utimes())
- __u64 max_size; // max size we can write to
+ uint64_t max_size; // max size we can write to
// dirfrag, recursive accountin
frag_info_t dirstat;
map<int,InodeCap*> caps; // mds -> InodeCap
InodeCap *auth_cap;
unsigned dirty_caps, flushing_caps;
- __u64 flushing_cap_seq;
+ uint64_t flushing_cap_seq;
__u16 flushing_cap_tid[CEPH_CAP_BITS];
int shared_gen, cache_gen;
int snap_caps, snap_cap_refs;
ObjectCacher::ObjectSet oset;
- __u64 reported_size, wanted_max_size, requested_max_size;
+ uint64_t reported_size, wanted_max_size, requested_max_size;
int ref; // ref count. 1 for each dentry, fh that links to me.
int ll_ref; // separate ref count for ll client
Inode *inode;
int64_t offset; // high bits: frag_t, low bits: an offset
- __u64 release_count;
+ uint64_t release_count;
map<frag_t, vector<DirEntry> > buffer;
DirResult(Inode *in) : inode(in), offset(0), release_count(0) {
// file caps
void check_cap_issue(Inode *in, InodeCap *cap, unsigned issued);
- void add_update_cap(Inode *in, int mds, __u64 cap_id,
+ void add_update_cap(Inode *in, int mds, uint64_t cap_id,
unsigned issued, unsigned seq, unsigned mseq, inodeno_t realm,
int flags);
void remove_cap(Inode *in, int mds);
void handle_cap_flushsnap_ack(Inode *in, class MClientCaps *m);
void handle_cap_grant(Inode *in, int mds, InodeCap *cap, class MClientCaps *m);
void cap_delay_requeue(Inode *in);
- void send_cap(Inode *in, int mds, InodeCap *cap, int used, int want, int retain, int flush, __u64 tid);
+ void send_cap(Inode *in, int mds, InodeCap *cap, int used, int want, int retain, int flush, uint64_t tid);
void check_caps(Inode *in, bool is_delayed);
void get_cap_ref(Inode *in, int cap);
void put_cap_ref(Inode *in, int cap);
void flush_snaps(Inode *in);
- void wait_sync_caps(__u64 want);
+ void wait_sync_caps(uint64_t want);
void queue_cap_snap(Inode *in, snapid_t seq=0);
void finish_cap_snap(Inode *in, CapSnap *capsnap, int used);
void _flushed_cap_snap(Inode *in, snapid_t seq);
Inode* insert_trace(MetaRequest *request, utime_t ttl, int mds);
void update_inode_file_bits(Inode *in,
- __u64 truncate_seq, __u64 truncate_size, __u64 size,
- __u64 time_warp_seq, utime_t ctime, utime_t mtime, utime_t atime,
+ uint64_t truncate_seq, uint64_t truncate_size, uint64_t size,
+ uint64_t time_warp_seq, utime_t ctime, utime_t mtime, utime_t atime,
int issued);
Inode *add_update_inode(InodeStat *st, utime_t ttl, int mds);
void insert_dentry_inode(Dir *dir, const string& dname, LeaseStat *dlease,
Fh *_create_fh(Inode *in, int flags, int cmode);
- int _read_sync(Fh *f, __u64 off, __u64 len, bufferlist *bl);
- int _read_async(Fh *f, __u64 off, __u64 len, bufferlist *bl);
+ int _read_sync(Fh *f, uint64_t off, uint64_t len, bufferlist *bl);
+ int _read_async(Fh *f, uint64_t off, uint64_t len, bufferlist *bl);
// internal interface
// call these with client_lock held!
int _create(Inode *in, const char *name, int flags, mode_t mode, Inode **inp, Fh **fhp, int uid=-1, int gid=-1);
int _release(Fh *fh);
loff_t _lseek(Fh *fh, loff_t offset, int whence);
- int _read(Fh *fh, __s64 offset, __u64 size, bufferlist *bl);
- int _write(Fh *fh, __s64 offset, __u64 size, const char *buf);
+ int _read(Fh *fh, int64_t offset, uint64_t size, bufferlist *bl);
+ int _write(Fh *fh, int64_t offset, uint64_t size, const char *buf);
int _flush(Fh *fh);
int _fsync(Fh *fh, bool syncdataonly);
int _sync_fs();
int fstat(int fd, struct stat *stbuf);
int sync_fs();
- __s64 drop_caches();
+ int64_t drop_caches();
// hpc lazyio
int lazyio_propogate(int fd, loff_t offset, size_t count);
object_t oid = file_object_t(oh, ol);
lock.Lock();
ceph_object_layout layout = client->osdmap->make_object_layout(oid, CEPH_CASDATA_RULE);
- __u64 size;
+ uint64_t size;
utime_t mtime;
client->objecter->stat(oid, layout, CEPH_NOSNAP, &size, &mtime, 0, new C_SafeCond(&lock, &cond, &ack));
while (!ack) cond.Wait(lock);
utime_t from = g_clock.now();
utime_t start = from;
- __u64 bytes = 0, total = 0;
+ uint64_t bytes = 0, total = 0;
for (loff_t i=0; i<chunks; i++) {
utime_t from = g_clock.now();
utime_t start = from;
- __u64 bytes = 0, total = 0;
+ uint64_t bytes = 0, total = 0;
for (unsigned i=0; i<chunks; i++) {
if (time_to_stop()) break;
struct stat st;
client->fstat(fd, &st);
- __u64 size = st.st_size;
+ uint64_t size = st.st_size;
dout(0) << "file " << filename << " size is " << size << dendl;
Filer *filer = client->filer;
inode.ino = st.st_ino;
client->describe_layout(fd, &inode.layout);
- __u64 pos = 0;
+ uint64_t pos = 0;
bufferlist from_before;
while (pos < size) {
int get = MIN(size-pos, 1048576);
Mutex stag_lock("fuse_ll.cc stag_lock");
int last_stag = 0;
-hash_map<__u64,int> snap_stag_map;
-hash_map<int,__u64> stag_snap_map;
+hash_map<uint64_t,int> snap_stag_map;
+hash_map<int,uint64_t> stag_snap_map;
#define FINO_INO(x) ((x) & ((1ull<<48)-1ull))
#define FINO_STAG(x) ((x) >> 48)
#define MAKE_FINO(i,s) ((i) | ((s) << 48))
-static __u64 fino_snap(__u64 fino)
+static uint64_t fino_snap(uint64_t fino)
{
Mutex::Locker l(stag_lock);
- __u64 stag = FINO_STAG(fino);
+ uint64_t stag = FINO_STAG(fino);
assert(stag_snap_map.count(stag));
return stag_snap_map[stag];
}
}
-static __u64 make_fake_ino(inodeno_t ino, snapid_t snapid)
+static uint64_t make_fake_ino(inodeno_t ino, snapid_t snapid)
{
Mutex::Locker l(stag_lock);
- __u64 stag;
+ uint64_t stag;
if (snap_stag_map.count(snapid) == 0) {
stag = ++last_stag;
snap_stag_map[snapid] = stag;
struct stat st;
memset(&st, 0, sizeof(st));
- __u64 snap = fino_snap(ino);
+ uint64_t snap = fino_snap(ino);
while (1) {
int r = client->readdir_r(dirp, &de);
/* just use u64 to align sanely on all archs */
struct ceph_ioctl_layout {
- __u64 stripe_unit, stripe_count, object_size;
- __u64 data_pool;
- __s64 preferred_osd;
+ uint64_t stripe_unit, stripe_count, object_size;
+ uint64_t data_pool;
+ int64_t preferred_osd;
};
#define CEPH_IOC_GET_LAYOUT _IOR(CEPH_IOCTL_MAGIC, 1, \
* file offset.
*/
struct ceph_ioctl_dataloc {
- __u64 file_offset; /* in+out: file offset */
- __u64 object_offset; /* out: offset in object */
- __u64 object_no; /* out: object # */
- __u64 object_size; /* out: object size */
+ uint64_t file_offset; /* in+out: file offset */
+ uint64_t object_offset; /* out: offset in object */
+ uint64_t object_no; /* out: object # */
+ uint64_t object_size; /* out: object size */
char object_name[64]; /* out: object name */
- __u64 block_offset; /* out: offset in block */
- __u64 block_size; /* out: block length */
- __s64 osd; /* out: osd # */
+ uint64_t block_offset; /* out: offset in block */
+ uint64_t block_size; /* out: block length */
+ int64_t osd; /* out: osd # */
struct sockaddr_storage osd_addr; /* out: osd address */
};
-__s64 Logger::inc(int key, __s64 v)
+int64_t Logger::inc(int key, int64_t v)
{
if (!open || !g_conf.logger)
return 0;
logger_lock.Lock();
int i = type->lookup_key(key);
vals[i] += v;
- __s64 r = vals[i];
+ int64_t r = vals[i];
logger_lock.Unlock();
return r;
}
return r;
}
-__s64 Logger::set(int key, __s64 v)
+int64_t Logger::set(int key, int64_t v)
{
if (!open || !g_conf.logger)
return 0;
logger_lock.Lock();
int i = type->lookup_key(key);
//cout << this << " set " << i << " to " << v << std::endl;
- __s64 r = vals[i] = v;
+ int64_t r = vals[i] = v;
logger_lock.Unlock();
return r;
}
return r;
}
-__s64 Logger::get(int key)
+int64_t Logger::get(int key)
{
if (!open || !g_conf.logger)
return 0;
logger_lock.Lock();
int i = type->lookup_key(key);
- __s64 r = 0;
+ int64_t r = 0;
if (i >= 0 && i < (int)vals.size())
r = vals[i];
logger_lock.Unlock();
bool open;
// values for this instance
- vector<__s64> vals;
+ vector<int64_t> vals;
vector<double> fvals;
vector< vector<double> > vals_to_avg; // for calculating variance
void _open_log();
- __s64 inc(int f, __s64 v = 1);
- __s64 set(int f, __s64 v);
- __s64 get(int f);
+ int64_t inc(int f, int64_t v = 1);
+ int64_t set(int f, int64_t v);
+ int64_t get(int f);
double fset(int f, double v);
double finc(int f, double v);
#include "Cond.h"
class Throttle {
- __u64 count, want, max;
+ uint64_t count, want, max;
Mutex lock;
Cond cond;
public:
- Throttle(__u64 m = 0) : count(0), max(m),
+ Throttle(uint64_t m = 0) : count(0), max(m),
lock("Throttle::lock") {}
private:
- void _reset_max(__u64 m) {
+ void _reset_max(uint64_t m) {
if (m) {
if (m < max)
cond.SignalAll();
max = m;
}
}
- bool _wait(__u64 c) {
+ bool _wait(uint64_t c) {
bool waited = false;
while (max && count + c > max) {
waited = true;
}
public:
- __u64 get_current() {
+ uint64_t get_current() {
Mutex::Locker l(lock);
return count;
}
- bool wait(__u64 m = 0) {
+ bool wait(uint64_t m = 0) {
Mutex::Locker l(lock);
_reset_max(m);
return _wait(0);
}
- __u64 take(__u64 c = 1) {
+ uint64_t take(uint64_t c = 1) {
Mutex::Locker l(lock);
count += c;
return count;
}
- bool get(__u64 c = 1, __u64 m = 0) {
+ bool get(uint64_t c = 1, uint64_t m = 0) {
Mutex::Locker l(lock);
_reset_max(m);
bool waited = _wait(c);
return waited;
}
- __u64 put(__u64 c = 1) {
+ uint64_t put(uint64_t c = 1) {
Mutex::Locker l(lock);
cond.SignalAll();
count -= c;
}
-void find_rabin_markers(bufferlist &bl, __u64 bloff, list<__u64> &chunks_offsets)
+void find_rabin_markers(bufferlist &bl, uint64_t bloff, list<uint64_t> &chunks_offsets)
{
return 0;
}
-int _dout_create_courtesy_output_symlink(const char *type, __s64 n)
+int _dout_create_courtesy_output_symlink(const char *type, int64_t n)
{
char name[20];
snprintf(name, sizeof(name), "%s%lld", type, (unsigned long long)n);
extern void _dout_open_log();
extern int _dout_rename_output_file(); // after calling daemon()
-extern int _dout_create_courtesy_output_symlink(const char *type, __s64 n);
+extern int _dout_create_courtesy_output_symlink(const char *type, int64_t n);
extern int _dout_create_courtesy_output_symlink(const char *name);
static inline void _dout_check_log() {
long long unsigned journaler_batch_max;
// mds
- __u64 mds_max_file_size;
+ uint64_t mds_max_file_size;
int mds_cache_size;
float mds_cache_mid;
int mds_mem_max;
cond.Wait(lock);
lock.Unlock();
- __u64 start = journaler->get_read_pos();
- __u64 end = journaler->get_write_pos();
- __u64 len = end-start;
+ uint64_t start = journaler->get_read_pos();
+ uint64_t end = journaler->get_write_pos();
+ uint64_t len = end-start;
cout << "journal is " << start << "~" << len << std::endl;
Filer filer(objecter);
assert(fd > 0);
- __u64 offset = bno * EBOFS_BLOCK_SIZE;
- __u64 actual = ::lseek64(fd, offset, SEEK_SET);
+ uint64_t offset = bno * EBOFS_BLOCK_SIZE;
+ uint64_t actual = ::lseek64(fd, offset, SEEK_SET);
assert(actual == offset);
size_t len = num*EBOFS_BLOCK_SIZE;
assert(fd > 0);
while (1) {
- __u64 offset = (__u64)bno << EBOFS_BLOCK_BITS;
- assert((__u64)bno * (__u64)EBOFS_BLOCK_SIZE == offset);
- __u64 actual = ::lseek64(fd, offset, SEEK_SET);
+ uint64_t offset = (uint64_t)bno << EBOFS_BLOCK_BITS;
+ assert((uint64_t)bno * (uint64_t)EBOFS_BLOCK_SIZE == offset);
+ uint64_t actual = ::lseek64(fd, offset, SEEK_SET);
assert(actual == offset);
// write buffers
#define DOUT_SUBSYS ebofs
-void do_apply_partial(bufferlist& bl, map<__u64, bufferlist>& pm)
+void do_apply_partial(bufferlist& bl, map<uint64_t, bufferlist>& pm)
{
assert(bl.length() == (unsigned)EBOFS_BLOCK_SIZE);
//assert(partial_is_complete());
//cout << "apply_partial" << std::endl;
- for (map<__u64, bufferlist>::iterator i = pm.begin();
+ for (map<uint64_t, bufferlist>::iterator i = pm.begin();
i != pm.end();
i++) {
//cout << "do_apply_partial at " << i->first << "~" << i->second.length() << std::endl;
#define dout_prefix *_dout << dbeginl << "ebofs." << *this << "."
-void BufferHead::add_partial(__u64 off, bufferlist& p)
+void BufferHead::add_partial(uint64_t off, bufferlist& p)
{
unsigned len = p.length();
assert(len <= (unsigned)EBOFS_BLOCK_SIZE);
assert(off + len <= EBOFS_BLOCK_SIZE);
// trim any existing that overlaps
- map<__u64, bufferlist>::iterator i = partial.begin();
+ map<uint64_t, bufferlist>::iterator i = partial.begin();
while (i != partial.end()) {
// is [off,off+len)...
// past i?
// overlap head of i?
if (off <= i->first && off+len < i->first + i->second.length()) {
// move i (make new tail).
- __u64 tailoff = off+len;
+ uint64_t tailoff = off+len;
unsigned trim = tailoff - i->first;
partial[tailoff].substr_of(i->second, trim, i->second.length()-trim);
partial.erase(i++); // should now be at tailoff
assert(exv[0].start != 0);
block_t cur_block = exv[0].start;
- __u64 off_in_bl = (bh->start() - start) * EBOFS_BLOCK_SIZE;
+ uint64_t off_in_bl = (bh->start() - start) * EBOFS_BLOCK_SIZE;
assert(off_in_bl >= 0);
- __u64 len_in_bl = bh->length() * EBOFS_BLOCK_SIZE;
+ uint64_t len_in_bl = bh->length() * EBOFS_BLOCK_SIZE;
// verify csum
csum_t want = *bh->oc->on->get_extent_csum_ptr(bh->start(), 1);
*bh->oc->on->get_extent_csum_ptr(bh->start(), 1) = got;
bh->oc->on->data_csum += got - want;
- interval_set<__u64> bad;
+ interval_set<uint64_t> bad;
bad.insert(bh->start()*EBOFS_BLOCK_SIZE, EBOFS_BLOCK_SIZE);
bh->oc->on->bad_byte_extents.union_of(bad);
- interval_set<__u64> over;
- for (map<__u64,bufferlist>::iterator q = bh->partial.begin();
+ interval_set<uint64_t> over;
+ for (map<uint64_t,bufferlist>::iterator q = bh->partial.begin();
q != bh->partial.end();
q++)
over.insert(bh->start()*EBOFS_BLOCK_SIZE+q->first, q->second.length());
- interval_set<__u64> new_over;
+ interval_set<uint64_t> new_over;
new_over.intersection_of(over, bh->oc->on->bad_byte_extents);
bh->oc->on->bad_byte_extents.subtract(new_over);
}
ioh_t tx_ioh; //
block_t tx_block;
- map<__u64, bufferlist> partial; // partial dirty content overlayed onto incoming data
+ map<uint64_t, bufferlist> partial; // partial dirty content overlayed onto incoming data
map<block_t, list<Context*> > waitfor_read;
shadows.clear();
}
- void copy_partial_substr(__u64 start, __u64 end, bufferlist& bl) {
- map<__u64, bufferlist>::iterator i = partial.begin();
+ void copy_partial_substr(uint64_t start, uint64_t end, bufferlist& bl) {
+ map<uint64_t, bufferlist>::iterator i = partial.begin();
// skip first bits (fully to left)
while ((i->first + i->second.length() < start) &&
unsigned bhlen = MIN(end-start, i->second.length());
bl.substr_of( i->second, bhoff, bhlen );
- __u64 pos = i->first + i->second.length();
+ uint64_t pos = i->first + i->second.length();
// have continuous to end?
for (i++; i != partial.end(); i++) {
assert(bl.length() == (unsigned)(end-start));
}
- bool have_partial_range(__u64 start, __u64 end) {
- map<__u64, bufferlist>::iterator i = partial.begin();
+ bool have_partial_range(uint64_t start, uint64_t end) {
+ map<uint64_t, bufferlist>::iterator i = partial.begin();
// skip first bits (fully to left)
while ((i->first + i->second.length() < start) &&
// have start?
if (i->first > start) return false;
- __u64 pos = i->first + i->second.length();
+ uint64_t pos = i->first + i->second.length();
// have continuous to end?
for (i++; i != partial.end(); i++) {
return false;
}
- bool partial_is_complete(__u64 size) {
+ bool partial_is_complete(uint64_t size) {
return have_partial_range( 0, MIN(size, EBOFS_BLOCK_SIZE) );
}
void apply_partial();
- void add_partial(__u64 off, bufferlist& p);
+ void add_partial(uint64_t off, bufferlist& p);
void take_read_waiters(list<Context*>& finished) {
for (map<block_t,list<Context*> >::iterator p = waitfor_read.begin();
Cond flush_cond;
int stat_waiter;
- __u64 stat_all;
- __u64 stat_clean, stat_corrupt;
- __u64 stat_dirty;
- __u64 stat_rx;
- __u64 stat_tx;
- __u64 stat_partial;
- __u64 stat_missing;
+ uint64_t stat_all;
+ uint64_t stat_clean, stat_corrupt;
+ uint64_t stat_dirty;
+ uint64_t stat_rx;
+ uint64_t stat_tx;
+ uint64_t stat_partial;
+ uint64_t stat_missing;
int partial_reads;
{}
- __u64 get_size() {
+ uint64_t get_size() {
assert(stat_clean+stat_dirty+stat_rx+stat_tx+stat_partial+stat_corrupt+stat_missing == stat_all);
return stat_all;
}
- __u64 get_trimmable() {
+ uint64_t get_trimmable() {
return stat_clean+stat_corrupt;
}
}
stat_all -= bh->length();
}
- __u64 get_stat_tx() { return stat_tx; }
- __u64 get_stat_rx() { return stat_rx; }
- __u64 get_stat_dirty() { return stat_dirty; }
- __u64 get_stat_clean() { return stat_clean; }
- __u64 get_stat_partial() { return stat_partial; }
+ uint64_t get_stat_tx() { return stat_tx; }
+ uint64_t get_stat_rx() { return stat_rx; }
+ uint64_t get_stat_dirty() { return stat_dirty; }
+ uint64_t get_stat_clean() { return stat_clean; }
+ uint64_t get_stat_partial() { return stat_partial; }
map<version_t, int> &get_unflushed(int what) {
while (1) {
bufferlist bl;
- __u64 seq;
+ uint64_t seq;
if (!journal->read_entry(bl, seq)) {
dout(3) << "mount replay: end of journal, done." << dendl;
break;
commit_starting = false;
// --- get ready for a new epoch ---
- __u64 last_op = op_seq;
+ uint64_t last_op = op_seq;
super_epoch++;
dirty = false;
}
// bad byte extents
- for (map<__u64,__u64>::iterator p = on->bad_byte_extents.m.begin();
+ for (map<uint64_t,uint64_t>::iterator p = on->bad_byte_extents.m.begin();
p != on->bad_byte_extents.m.end();
p++) {
extent_t o = {p->first, p->second};
ebofs_lock.Unlock();
}
-void Ebofs::trim_bc(__s64 max)
+void Ebofs::trim_bc(int64_t max)
{
if (max < 0)
max = g_conf.ebofs_bc_size;
dout(10) << "trim_bc start: size " << bc.get_size() << ", trimmable " << bc.get_trimmable() << ", max " << max << dendl;
- while (bc.get_size() > (__u64)max &&
+ while (bc.get_size() > (uint64_t)max &&
bc.get_trimmable()) {
BufferHead *bh = (BufferHead*) bc.lru_rest.lru_expire();
if (!bh) break;
}
-int Ebofs::check_partial_edges(Onode *on, __u64 off, __u64 len,
+int Ebofs::check_partial_edges(Onode *on, uint64_t off, uint64_t len,
bool &partial_head, bool &partial_tail)
{
// partial block overwrite at head or tail?
- __u64 last_block_byte = on->last_block * EBOFS_BLOCK_SIZE;
+ uint64_t last_block_byte = on->last_block * EBOFS_BLOCK_SIZE;
partial_head = (off < last_block_byte) && (off & EBOFS_BLOCK_MASK);
partial_tail = ((off+len) < on->object_size) && ((off+len) & EBOFS_BLOCK_MASK);
dout(10) << "check_partial_edges on " << *on << " " << off << "~" << len
return -1;
}
if (bh->is_partial()) {
- __u64 off_in_bh = off & EBOFS_BLOCK_MASK;
- __u64 end_in_bh = MAX(EBOFS_BLOCK_SIZE, off_in_bh+len);
- __u64 end = EBOFS_BLOCK_SIZE;
+ uint64_t off_in_bh = off & EBOFS_BLOCK_MASK;
+ uint64_t end_in_bh = MAX(EBOFS_BLOCK_SIZE, off_in_bh+len);
+ uint64_t end = EBOFS_BLOCK_SIZE;
if (bh->end()*EBOFS_BLOCK_SIZE > last_block_byte)
end = last_block_byte & EBOFS_BLOCK_MASK;
if (!(off_in_bh == 0 || bh->have_partial_range(0, off_in_bh)) ||
return 0;
}
-int Ebofs::apply_write(Onode *on, __u64 off, __u64 len, const bufferlist& bl)
+int Ebofs::apply_write(Onode *on, uint64_t off, uint64_t len, const bufferlist& bl)
{
ObjectCache *oc = on->get_oc(&bc);
//oc->scrub_csums();
assert(bl.length() == len);
// map into blocks
- __u64 opos = off; // byte pos in object
- __u64 left = len; // bytes left
+ uint64_t opos = off; // byte pos in object
+ uint64_t left = len; // bytes left
block_t bstart = off / EBOFS_BLOCK_SIZE;
block_t blast = (len+off-1) / EBOFS_BLOCK_SIZE;
block_t blen = blast-bstart+1;
// -- starting changing stuff --
// extending object?
- __u64 old_object_size = on->object_size;
+ uint64_t old_object_size = on->object_size;
if (off+len > on->object_size) {
dout(10) << "apply_write extending size on " << *on << ": " << on->object_size
<< " -> " << off+len << dendl;
if (bh->is_corrupt()) {
dout(10) << "apply_write marking non-overwritten bytes bad on corrupt " << *bh << dendl;
- interval_set<__u64> bad;
- __u64 bs = bh->start() * EBOFS_BLOCK_SIZE;
+ interval_set<uint64_t> bad;
+ uint64_t bs = bh->start() * EBOFS_BLOCK_SIZE;
if (off_in_bh) bad.insert(bs, bs+off_in_bh);
if (off_in_bh+len_in_bh < (unsigned)EBOFS_BLOCK_SIZE)
bad.insert(bs+off_in_bh+len_in_bh, bs+EBOFS_BLOCK_SIZE-off_in_bh-len_in_bh);
// ok
// we're now writing up to a block boundary, or EOF.
- assert(off_in_bh+left >= (__u64)(EBOFS_BLOCK_SIZE*bh->length()) ||
+ assert(off_in_bh+left >= (uint64_t)(EBOFS_BLOCK_SIZE*bh->length()) ||
(opos+left) >= on->object_size);
- unsigned len_in_bh = MIN((__u64)bh->length()*EBOFS_BLOCK_SIZE - off_in_bh,
+ unsigned len_in_bh = MIN((uint64_t)bh->length()*EBOFS_BLOCK_SIZE - off_in_bh,
left);
assert(len_in_bh <= left);
// zero leader?
if (off_in_bh &&
opos > old_object_size) {
- __u64 zstart = MAX(0, old_object_size-(__u64)bh->start()*EBOFS_BLOCK_SIZE);
- __u64 zlen = off_in_bh - zstart;
+ uint64_t zstart = MAX(0, old_object_size-(uint64_t)bh->start()*EBOFS_BLOCK_SIZE);
+ uint64_t zlen = off_in_bh - zstart;
dout(15) << "apply_write zeroing bh lead over " << zstart << "~" << zlen << dendl;
bh->data.zero(zstart, zlen);
}
// zero the past-eof tail, too, to be tidy.
if (len_in_bh < bh->data.length()) {
- __u64 zstart = off_in_bh+len_in_bh;
- __u64 zlen = bh->data.length()-(off_in_bh+len_in_bh);
+ uint64_t zstart = off_in_bh+len_in_bh;
+ uint64_t zlen = bh->data.length()-(off_in_bh+len_in_bh);
bh->data.zero(zstart, zlen);
dout(15) << "apply_write zeroing bh tail over " << zstart << "~" << zlen << dendl;
}
}
-int Ebofs::apply_zero(Onode *on, __u64 off, size_t len)
+int Ebofs::apply_zero(Onode *on, uint64_t off, size_t len)
{
dout(10) << "apply_zero " << off << "~" << len << " on " << *on << dendl;
// *** file i/o ***
-int Ebofs::attempt_read(Onode *on, __u64 off, size_t len, bufferlist& bl,
+int Ebofs::attempt_read(Onode *on, uint64_t off, size_t len, bufferlist& bl,
Cond *will_wait_on, bool *will_wait_on_bool)
{
dout(10) << "attempt_read " << *on << " " << off << "~" << len << dendl;
return -EIO;
}
if (on->bad_byte_extents.end() > off) {
- __u64 bad = on->bad_byte_extents.start_after(off);
- if (bad < off+(__u64)len) {
+ uint64_t bad = on->bad_byte_extents.start_after(off);
+ if (bad < off+(uint64_t)len) {
len = bad-off;
dout(10) << "attempt_read corrupt (bad byte extent) at " << bad << ", shortening read to " << len << dendl;
}
i != partials.end();
i++) {
BufferHead *bh = i->second;
- __u64 bhstart = (__u64)(bh->start()*EBOFS_BLOCK_SIZE);
- __u64 bhend = (__u64)(bh->end()*EBOFS_BLOCK_SIZE);
- __u64 start = MAX( off, bhstart );
- __u64 end = MIN( off+(__u64)len, bhend );
+ uint64_t bhstart = (uint64_t)(bh->start()*EBOFS_BLOCK_SIZE);
+ uint64_t bhend = (uint64_t)(bh->end()*EBOFS_BLOCK_SIZE);
+ uint64_t start = MAX( off, bhstart );
+ uint64_t end = MIN( off+(uint64_t)len, bhend );
if (!i->second->have_partial_range(start-bhstart, end-bhstart)) {
// wait on this one
map<block_t,BufferHead*>::iterator p = partials.begin();
bl.clear();
- __u64 pos = off;
+ uint64_t pos = off;
block_t curblock = bstart;
while (curblock <= blast) {
BufferHead *bh = 0;
p++;
} else assert(0);
- __u64 bhstart = (__u64)(bh->start()*EBOFS_BLOCK_SIZE);
- __u64 bhend = (__u64)(bh->end()*EBOFS_BLOCK_SIZE);
- __u64 start = MAX( pos, bhstart );
- __u64 end = MIN( off+(__u64)len, bhend );
+ uint64_t bhstart = (uint64_t)(bh->start()*EBOFS_BLOCK_SIZE);
+ uint64_t bhend = (uint64_t)(bh->end()*EBOFS_BLOCK_SIZE);
+ uint64_t start = MAX( pos, bhstart );
+ uint64_t end = MIN( off+(uint64_t)len, bhend );
if (bh->is_corrupt()) {
if (bl.length()) {
* return value of -1 if onode isn't loaded. otherwise, the number
* of extents that need to be read (i.e. # of seeks)
*/
-int Ebofs::is_cached(coll_t cid, pobject_t oid, __u64 off, size_t len)
+int Ebofs::is_cached(coll_t cid, pobject_t oid, uint64_t off, size_t len)
{
ebofs_lock.Lock();
int r = _is_cached(oid, off, len);
return r;
}
-int Ebofs::_is_cached(pobject_t oid, __u64 off, size_t len)
+int Ebofs::_is_cached(pobject_t oid, uint64_t off, size_t len)
{
if (!have_onode(oid)) {
dout(7) << "_is_cached " << oid << " " << off << "~" << len << " ... onode " << dendl;
*/
}
-void Ebofs::trim_from_cache(coll_t cid, pobject_t oid, __u64 off, size_t len)
+void Ebofs::trim_from_cache(coll_t cid, pobject_t oid, uint64_t off, size_t len)
{
ebofs_lock.Lock();
_trim_from_cache(oid, off, len);
ebofs_lock.Unlock();
}
-void Ebofs::_trim_from_cache(pobject_t oid, __u64 off, size_t len)
+void Ebofs::_trim_from_cache(pobject_t oid, uint64_t off, size_t len)
{
// be careful not to load it if we don't have it
if (!have_onode(oid)) {
int Ebofs::read(coll_t cid, pobject_t oid,
- __u64 off, size_t len,
+ uint64_t off, size_t len,
bufferlist& bl)
{
ebofs_lock.Lock();
return r;
}
-int Ebofs::_read(pobject_t oid, __u64 off, size_t len, bufferlist& bl)
+int Ebofs::_read(pobject_t oid, uint64_t off, size_t len, bufferlist& bl)
{
dout(7) << "_read " << oid << " " << off << "~" << len << dendl;
}
size_t try_len = len ? len:on->object_size;
- size_t will_read = MIN(off+(__u64)try_len, on->object_size) - off;
+ size_t will_read = MIN(off+(uint64_t)try_len, on->object_size) - off;
bool done;
r = attempt_read(on, off, will_read, bl, &cond, &done);
{
coll_t cid = t.get_cid();
pobject_t oid = t.get_oid();
- __u64 offset = t.get_length();
- __u64 len = t.get_length();
+ uint64_t offset = t.get_length();
+ uint64_t len = t.get_length();
bufferlist& bl = t.get_bl();
if (_write(cid, oid, offset, len, bl) < 0) {
dout(7) << "apply_transaction fail on _write" << dendl;
{
coll_t cid = t.get_cid();
pobject_t oid = t.get_oid();
- __u64 offset = t.get_length();
- __u64 len = t.get_length();
+ uint64_t offset = t.get_length();
+ uint64_t len = t.get_length();
if (_zero(cid, oid, offset, len) < 0) {
dout(7) << "apply_transaction fail on _zero" << dendl;
r &= bit;
{
coll_t cid = t.get_cid();
pobject_t oid = t.get_oid();
- __u64 offset = t.get_length();
- __u64 len = t.get_length();
+ uint64_t offset = t.get_length();
+ uint64_t len = t.get_length();
_trim_from_cache(oid, offset, len);
}
break;
{
coll_t cid = t.get_cid();
pobject_t oid = t.get_oid();
- __u64 offset = t.get_length();
+ uint64_t offset = t.get_length();
if (_truncate(cid, oid, offset) < 0) {
dout(7) << "apply_transaction fail on _truncate" << dendl;
r &= bit;
coll_t cid = t.get_cid();
pobject_t oid = t.get_oid();
pobject_t noid = t.get_oid();
- __u64 off = t.get_length();
- __u64 len = t.get_length();
+ uint64_t off = t.get_length();
+ uint64_t len = t.get_length();
if (_clone_range(cid, oid, noid, off, len) < 0) {
dout(7) << "apply_transaction fail on _clone_range" << dendl;
r &= bit;
}
-int Ebofs::_write(coll_t cid, pobject_t oid, __u64 offset, size_t length, const bufferlist& bl)
+int Ebofs::_write(coll_t cid, pobject_t oid, uint64_t offset, size_t length, const bufferlist& bl)
{
dout(7) << "_write " << cid << " " << oid << " " << offset << "~" << length << dendl;
assert(bl.length() == length);
return length;
}
-int Ebofs::_zero(coll_t cid, pobject_t oid, __u64 offset, size_t length)
+int Ebofs::_zero(coll_t cid, pobject_t oid, uint64_t offset, size_t length)
{
dout(7) << "_zero " << oid << " " << offset << "~" << length << dendl;
if (length > 0 &&
offset < on->object_size) {
- if (offset + (__u64)length >= on->object_size) {
+ if (offset + (uint64_t)length >= on->object_size) {
_truncate(cid, oid, offset);
} else {
while (1) {
int Ebofs::write(coll_t cid, pobject_t oid,
- __u64 off, size_t len,
+ uint64_t off, size_t len,
const bufferlist& bl, Context *onsafe)
{
ebofs_lock.Lock();
return r;
}
-int Ebofs::zero(coll_t cid, pobject_t oid, __u64 off, size_t len, Context *onsafe)
+int Ebofs::zero(coll_t cid, pobject_t oid, uint64_t off, size_t len, Context *onsafe)
{
ebofs_lock.Lock();
return r;
}
-int Ebofs::_truncate(coll_t cid, pobject_t oid, __u64 size)
+int Ebofs::_truncate(coll_t cid, pobject_t oid, uint64_t size)
{
dout(7) << "_truncate " << oid << " size " << size << dendl;
}
-int Ebofs::truncate(coll_t cid, pobject_t oid, __u64 size, Context *onsafe)
+int Ebofs::truncate(coll_t cid, pobject_t oid, uint64_t size, Context *onsafe)
{
ebofs_lock.Lock();
}
-int Ebofs::_clone_range(coll_t cid, pobject_t from, pobject_t to, __u64 off, __u64 len)
+int Ebofs::_clone_range(coll_t cid, pobject_t from, pobject_t to, uint64_t off, uint64_t len)
{
dout(7) << "_clone_range " << from << " -> " << to << " " << off << "~" << len << dendl;
bool mounted, unmounting, dirty;
bool readonly;
version_t super_epoch;
- __u64 op_seq;
+ uint64_t op_seq;
bool commit_starting;
bool commit_thread_started;
Cond commit_cond; // to wake up the commit thread
version_t trigger_commit();
void commit_bc_wait(version_t epoch);
- void trim_bc(__s64 max = -1);
+ void trim_bc(int64_t max = -1);
public:
void kick_idle();
protected:
- int check_partial_edges(Onode *on, __u64 off, __u64 len,
+ int check_partial_edges(Onode *on, uint64_t off, uint64_t len,
bool &partial_head, bool &partial_tail);
void alloc_write(Onode *on,
interval_set<block_t>& alloc,
block_t& old_bfirst, block_t& old_blast,
csum_t& old_csum_first, csum_t& old_csum_last);
- int apply_write(Onode *on, __u64 off, __u64 len, const bufferlist& bl);
- int apply_zero(Onode *on, __u64 off, size_t len);
- int attempt_read(Onode *on, __u64 off, size_t len, bufferlist& bl,
+ int apply_write(Onode *on, uint64_t off, uint64_t len, const bufferlist& bl);
+ int apply_zero(Onode *on, uint64_t off, size_t len);
+ int attempt_read(Onode *on, uint64_t off, size_t len, bufferlist& bl,
Cond *will_wait_on, bool *will_wait_on_bool);
Finisher finisher;
// object interface
bool exists(coll_t cid, pobject_t);
int stat(coll_t cid, pobject_t, struct stat*);
- int read(coll_t cid, pobject_t, __u64 off, size_t len, bufferlist& bl);
- int is_cached(coll_t cid, pobject_t oid, __u64 off, size_t len);
+ int read(coll_t cid, pobject_t, uint64_t off, size_t len, bufferlist& bl);
+ int is_cached(coll_t cid, pobject_t oid, uint64_t off, size_t len);
- int write(coll_t cid, pobject_t oid, __u64 off, size_t len, const bufferlist& bl, Context *onsafe);
- int zero(coll_t cid, pobject_t oid, __u64 off, size_t len, Context *onsafe);
- int truncate(coll_t cid, pobject_t oid, __u64 size, Context *onsafe=0);
+ int write(coll_t cid, pobject_t oid, uint64_t off, size_t len, const bufferlist& bl, Context *onsafe);
+ int zero(coll_t cid, pobject_t oid, uint64_t off, size_t len, Context *onsafe);
+ int truncate(coll_t cid, pobject_t oid, uint64_t size, Context *onsafe=0);
int remove(coll_t cid, pobject_t oid, Context *onsafe=0);
bool write_will_block();
- void trim_from_cache(coll_t cid, pobject_t oid, __u64 off, size_t len);
+ void trim_from_cache(coll_t cid, pobject_t oid, uint64_t off, size_t len);
int rename(pobject_t from, pobject_t to);
int clone(coll_t cid, pobject_t from, pobject_t to, Context *onsafe);
// private interface -- use if caller already holds lock
unsigned _apply_transaction(Transaction& t);
- int _read(pobject_t oid, __u64 off, size_t len, bufferlist& bl);
- int _is_cached(pobject_t oid, __u64 off, size_t len);
+ int _read(pobject_t oid, uint64_t off, size_t len, bufferlist& bl);
+ int _is_cached(pobject_t oid, uint64_t off, size_t len);
int _stat(pobject_t oid, struct stat *st);
int _getattr(pobject_t oid, const char *name, void *value, size_t size);
int _getattr(pobject_t oid, const char *name, bufferptr& bp);
bool _write_will_block();
int _touch(coll_t cid, pobject_t oid);
- int _write(coll_t cid, pobject_t oid, __u64 off, size_t len, const bufferlist& bl);
- void _trim_from_cache(pobject_t oid, __u64 off, size_t len);
- int _truncate(coll_t cid, pobject_t oid, __u64 size);
- int _zero(coll_t cid, pobject_t oid, __u64 offset, size_t length);
+ int _write(coll_t cid, pobject_t oid, uint64_t off, size_t len, const bufferlist& bl);
+ void _trim_from_cache(pobject_t oid, uint64_t off, size_t len);
+ int _truncate(coll_t cid, pobject_t oid, uint64_t size);
+ int _zero(coll_t cid, pobject_t oid, uint64_t offset, size_t length);
int _remove(coll_t cid, pobject_t oid);
int _clone(coll_t cid, pobject_t from, pobject_t to);
- int _clone_range(coll_t cid, pobject_t from, pobject_t to, __u64 off, __u64 len);
+ int _clone_range(coll_t cid, pobject_t from, pobject_t to, uint64_t off, uint64_t len);
int _setattr(pobject_t oid, const char *name, const void *value, size_t size);
int _setattrs(pobject_t oid, map<nstring,bufferptr>& attrset);
int _rmattr(pobject_t oid, const char *name);
extent_t onode_loc;
epoch_t last_alloc_epoch; // epoch i last allocated for
- __u64 object_size;
- __u64 alloc_blocks, last_block;
+ uint64_t object_size;
+ uint64_t alloc_blocks, last_block;
csum_t data_csum;
bool readonly;
map<nstring, bufferptr> attr;
map<block_t, ExtentCsum> extent_map;
- interval_set<__u64> bad_byte_extents;
+ interval_set<uint64_t> bad_byte_extents;
interval_set<block_t> uncommitted;
#ifndef __EBOFS_CSUM_H
#define __EBOFS_CSUM_H
-typedef __u64 csum_t;
+typedef uint64_t csum_t;
/*
* physically and logically aligned buffer. yay.
*/
-inline __u64 calc_csum(const char *start, int len) {
+inline uint64_t calc_csum(const char *start, int len) {
// must be 64-bit aligned
assert(((unsigned long)start & 7) == 0);
assert((len & 7) == 0);
- __u64 *p = (__u64*)start;
- __u64 *end = (__u64*)(start + len);
- __u64 csum = 0;
+ uint64_t *p = (uint64_t*)start;
+ uint64_t *end = (uint64_t*)(start + len);
+ uint64_t csum = 0;
while (p < end) {
csum += *p;
p++;
* arbitrarily aligned buffer. buffer alignment must match logical alignment.
* i.e., buffer content is aligned, but has non-aligned boundaries.
*/
-inline __u64 calc_csum_unaligned(const char *start, int len) {
+inline uint64_t calc_csum_unaligned(const char *start, int len) {
const char *end = start + len;
- __u64 csum = 0;
+ uint64_t csum = 0;
// front
while (start < end && (unsigned long)start & 7) {
- csum += (__u64)(*start) << (8*(8 - ((unsigned long)start & 7)));
+ csum += (uint64_t)(*start) << (8*(8 - ((unsigned long)start & 7)));
start++;
}
if (start == end)
// middle, aligned
const char *fastend = end - 7;
while (start < fastend) {
- csum += *(__u64*)start;
- start += sizeof(__u64);
+ csum += *(uint64_t*)start;
+ start += sizeof(uint64_t);
}
// tail
while (start < end) {
- csum += (__u64)(*start) << (8*(8 - ((unsigned long)start & 7)));
+ csum += (uint64_t)(*start) << (8*(8 - ((unsigned long)start & 7)));
start++;
}
return csum;
/*
* arbitrarily aligned buffer, with arbitrary logical alignment
*/
-inline __u64 calc_csum_realign(const char *start, int len, int off) {
+inline uint64_t calc_csum_realign(const char *start, int len, int off) {
const char *end = start + len;
- __u64 csum = 0;
+ uint64_t csum = 0;
if (((unsigned long)start & 7) == ((unsigned long)off & 7))
return calc_csum_unaligned(start, len); // lucky us, start and off alignment matches.
// do it the slow way. yucky!
while (start < end) {
- csum += (__u64)(*start) << (8*(8 - (off & 7)));
+ csum += (uint64_t)(*start) << (8*(8 - (off & 7)));
start++; off++;
}
return csum;
pobject_t oid(0, 0, object_t(1,2));
- __u64 pos = 0;
- __u64 sz = 16;
+ uint64_t pos = 0;
+ uint64_t sz = 16;
bufferlist bl;
bl.append(crap, sz);
char *p = bl.c_str();
- __u64 o = 0;
+ uint64_t o = 0;
for (int i=0; i<n; i++) {
cout << "write at " << o << std::endl;
for (int j=0;j<l;j++)
utime_t start = g_clock.now();
- for (__u64 m=0; m<megs; m++) {
+ for (uint64_t m=0; m<megs; m++) {
//if (m%100 == 0)
cout << m << " / " << megs << std::endl;
fs.write(10, bl.length(), 1024LL*1024LL*m, bl, (Context*)0);
if (1) {
srand(0);
for (int i=0; i<10000; i++) {
- __u64 off = rand() % 1000000;
+ uint64_t off = rand() % 1000000;
size_t len = 1+rand() % 10000;
cout << std::endl << i << " writing bit at " << off << " len " << len << std::endl;
fs.write(10, len, off, bl, (Context*)0);
}
fs.remove(10);
for (int i=0; i<100; i++) {
- __u64 off = rand() % 1000000;
+ uint64_t off = rand() % 1000000;
size_t len = 1+rand() % 10000;
cout << std::endl << i << " writing bit at " << off << " len " << len << std::endl;
fs.write(10, len, off, bl, (Context*)0);
if (0) {
// sequential write
srand(0);
- __u64 off = 0;
+ uint64_t off = 0;
for (int i=0; i<10000; i++) {
size_t len = 1024*1024;//1+rand() % 10000;
cout << std::endl << i << " writing bit at " << off << " len " << len << std::endl;
srand(0);
for (int i=0; i<100; i++) {
bufferlist bl;
- __u64 off = rand() % 1000000;
+ uint64_t off = rand() % 1000000;
size_t len = rand() % 1000;
cout << std::endl << "read bit at " << off << " len " << len << std::endl;
int r = fs.read(10, len, off, bl);
srand(0);
for (int i=0; i<100; i++) {
bufferlist bl;
- __u64 off = rand() % 1000000;
+ uint64_t off = rand() % 1000000;
size_t len = 100;
cout << std::endl << "read bit at " << off << " len " << len << std::endl;
int r = fs.read(10, len, off, bl);
// write on empty cache
srand(0);
for (int i=0; i<100; i++) {
- __u64 off = rand() % 1000000;
+ uint64_t off = rand() % 1000000;
size_t len = 100;
cout << std::endl << "writing bit at " << off << " len " << len << std::endl;
fs.write(10, len, off, bl, (Context*)0);
char fingerprint_byte_at(int pos, int seed)
{
- __u64 big = ((pos & ~7) / 133) ^ seed;
+ uint64_t big = ((pos & ~7) / 133) ^ seed;
return ((char*)&big)[pos & 7];
}
pobject_t oid;
oid.oid.ino = (rand() % 1000) + 0x10000000;
coll_t cid = rand() % 50;
- __u64 off = rand() % 10000;//0;//rand() % 1000000;
- __u64 len = 1+rand() % 100000;
+ uint64_t off = rand() % 10000;//0;//rand() % 1000000;
+ uint64_t len = 1+rand() % 100000;
const char *a = "one";
if (rand() % 2) a = "two";
int l = 3;//rand() % 10;
extent_t onode_loc; /* this is actually the block we live in */
pobject_t object_id; /* for kicks */
- __u64 readonly;
+ uint64_t readonly;
- __s64 object_size; /* file size in bytes. should this be 64-bit? */
+ int64_t object_size; /* file size in bytes. should this be 64-bit? */
__u32 alloc_blocks; // allocated
csum_t data_csum;
// tree/set nodes
//typedef int nodeid_t;
-typedef __s64 nodeid_t; // actually, a block number. FIXME.
+typedef int64_t nodeid_t; // actually, a block number. FIXME.
static const unsigned EBOFS_NODE_BLOCKS = 1;
static const unsigned EBOFS_NODE_BYTES = EBOFS_NODE_BLOCKS * EBOFS_BLOCK_SIZE;
struct ebofs_node_ptr {
nodeid_t nodeid;
- //__u64 start[EBOFS_NODE_DUP];
- //__u64 length;
+ //uint64_t start[EBOFS_NODE_DUP];
+ //uint64_t length;
csum_t csum;
} __attribute__ ((packed));
// super
typedef uint64_t version_t;
-static const __u64 EBOFS_MAGIC = 0x000EB0F5;
+static const uint64_t EBOFS_MAGIC = 0x000EB0F5;
static const int EBOFS_NUM_FREE_BUCKETS = 5; /* see alloc.h for bucket constraints */
static const int EBOFS_FREE_BUCKET_BITS = 2;
struct ebofs_super {
- __u64 s_magic;
- __u64 fsid; /* _ebofs_ fsid, mind you, not ceph_fsid_t. */
+ uint64_t s_magic;
+ uint64_t fsid; /* _ebofs_ fsid, mind you, not ceph_fsid_t. */
epoch_t epoch; // version of this superblock.
- __u64 op_seq; // seq # of last operation we _did_ apply+commit to the store.
+ uint64_t op_seq; // seq # of last operation we _did_ apply+commit to the store.
uint64_t num_blocks; /* # blocks in filesystem */
struct CompatSet {
struct Feature {
- __u64 id;
+ uint64_t id;
string name;
- Feature(__u64 _id, const char *_name) : id(_id), name(_name) {}
- Feature(__u64 _id, string& _name) : id(_id), name(_name) {}
+ Feature(uint64_t _id, const char *_name) : id(_id), name(_name) {}
+ Feature(uint64_t _id, string& _name) : id(_id), name(_name) {}
};
struct FeatureSet {
- __u64 mask;
- map <__u64,string> names;
+ uint64_t mask;
+ map <uint64_t,string> names;
FeatureSet() : mask(0), names() {}
void insert(Feature f) {
*/
CompatSet unsupported(CompatSet& other) {
CompatSet diff;
- __u64 other_compat =
+ uint64_t other_compat =
((other.compat.mask ^ compat.mask) & other.compat.mask);
- __u64 other_ro_compat =
+ uint64_t other_ro_compat =
((other.ro_compat.mask ^ ro_compat.mask) & other.ro_compat.mask);
- __u64 other_incompat =
+ uint64_t other_incompat =
((other.incompat.mask ^ incompat.mask) & other.incompat.mask);
for (int i = 0; i < 64; ++i) {
int mask = 1 << i;
struct LogEntryKey {
entity_inst_t who;
utime_t stamp;
- __u64 seq;
+ uint64_t seq;
LogEntryKey() {}
- LogEntryKey(entity_inst_t w, utime_t t, __u64 s) : who(w), stamp(t), seq(s) {}
+ LogEntryKey(entity_inst_t w, utime_t t, uint64_t s) : who(w), stamp(t), seq(s) {}
void encode(bufferlist& bl) const {
::encode(who, bl);
struct LogEntry {
entity_inst_t who;
utime_t stamp;
- __u64 seq;
+ uint64_t seq;
log_type type;
string msg;
((val << 8) & 0xff0000) |
((val << 24)));
}
-static __inline__ __u64 swab64(__u64 val)
+static __inline__ uint64_t swab64(uint64_t val)
{
return (( val >> 56) |
((val >> 40) & 0xff00ull) |
#define cpu_to_le32(x) (x)
#define cpu_to_le16(x) (x)
*/
-#define le64_to_cpu(x) ((__u64)x)
+#define le64_to_cpu(x) ((uint64_t)x)
#define le32_to_cpu(x) ((__u32)x)
#define le16_to_cpu(x) ((__u16)x)
// int types
#define WRITE_INTTYPE_ENCODER(type, etype) \
- inline void encode(__##type v, bufferlist& bl) { \
+ inline void encode(type v, bufferlist& bl) { \
__##etype e = init_##etype(v); \
encode_raw(e, bl); \
} \
- inline void decode(__##type &v, bufferlist::iterator& p) { \
+ inline void decode(type &v, bufferlist::iterator& p) { \
__##etype e; \
decode_raw(e, p); \
v = e; \
}
-WRITE_INTTYPE_ENCODER(u64, le64)
-WRITE_INTTYPE_ENCODER(s64, le64)
-WRITE_INTTYPE_ENCODER(u32, le32)
-WRITE_INTTYPE_ENCODER(s32, le32)
-WRITE_INTTYPE_ENCODER(u16, le16)
-WRITE_INTTYPE_ENCODER(s16, le16)
+WRITE_INTTYPE_ENCODER(uint64_t, le64)
+WRITE_INTTYPE_ENCODER(int64_t, le64)
+WRITE_INTTYPE_ENCODER(uint32_t, le32)
+WRITE_INTTYPE_ENCODER(int32_t, le32)
+WRITE_INTTYPE_ENCODER(uint16_t, le16)
+WRITE_INTTYPE_ENCODER(int16_t, le16)
}
};
-template<> struct rjhash<__u64> {
- inline size_t operator()(const __u64 x) const {
- return rjhash64(x);
- }
-};
-
#if defined(__CYGWIN__) || defined(DARWIN)
template<> struct rjhash<size_t> {
inline size_t operator()(const size_t x) const {
class interval_set {
public:
map<T,T> m; // map start -> len
- __u64 _size;
+ uint64_t _size;
interval_set() : _size(0) {}
/* pools */
typedef void *rados_pool_t;
typedef void *rados_list_ctx_t;
-typedef __u64 rados_snap_t;
+typedef uint64_t rados_snap_t;
struct rados_pool_stat_t {
- __u64 num_bytes; // in bytes
- __u64 num_kb; // in KB
- __u64 num_objects;
- __u64 num_object_clones;
- __u64 num_object_copies; // num_objects * num_replicas
- __u64 num_objects_missing_on_primary;
- __u64 num_objects_degraded;
- __u64 num_rd, num_rd_kb,num_wr, num_wr_kb;
+ uint64_t num_bytes; // in bytes
+ uint64_t num_kb; // in KB
+ uint64_t num_objects;
+ uint64_t num_object_clones;
+ uint64_t num_object_copies; // num_objects * num_replicas
+ uint64_t num_objects_missing_on_primary;
+ uint64_t num_objects_degraded;
+ uint64_t num_rd, num_rd_kb,num_wr, num_wr_kb;
};
struct rados_statfs_t {
- __u64 kb, kb_used, kb_avail;
- __u64 num_objects;
+ uint64_t kb, kb_used, kb_avail;
+ uint64_t num_objects;
};
int rados_open_pool(const char *name, rados_pool_t *pool);
void rados_set_snap(rados_pool_t pool, rados_snap_t snap);
int rados_create_pool(const char *name);
-int rados_create_pool_with_auid(const char *name, __u64 auid);
+int rados_create_pool_with_auid(const char *name, uint64_t auid);
int rados_delete_pool(const rados_pool_t pool);
-int rados_change_pool_auid(const rados_pool_t pool, __u64 auid);
+int rados_change_pool_auid(const rados_pool_t pool, uint64_t auid);
/* objects */
int rados_list_objects_open(rados_pool_t pool, rados_list_ctx_t *ctx);
int rados_setxattr(rados_pool_t pool, const char *o, const char *name, const char *buf, size_t len);
/* misc */
-int rados_stat(rados_pool_t pool, const char *o, __u64 *psize, time_t *pmtime);
+int rados_stat(rados_pool_t pool, const char *o, uint64_t *psize, time_t *pmtime);
int rados_tmap_update(rados_pool_t pool, const char *o, const char *cmdbuf, size_t cmdbuflen);
int rados_exec(rados_pool_t pool, const char *oid, const char *cls, const char *method,
const char *in_buf, size_t in_len, char *buf, size_t out_len);
typedef void *list_ctx_t;
typedef void *pool_t;
- typedef __u64 snap_t;
- typedef __u64 auid_t;
+ typedef uint64_t snap_t;
+ typedef uint64_t auid_t;
struct statfs_t {
- __u64 kb, kb_used, kb_avail;
- __u64 num_objects;
+ uint64_t kb, kb_used, kb_avail;
+ uint64_t num_objects;
};
struct pool_stat_t {
- __u64 num_bytes; // in bytes
- __u64 num_kb; // in KB
- __u64 num_objects;
- __u64 num_object_clones;
- __u64 num_object_copies; // num_objects * num_replicas
- __u64 num_objects_missing_on_primary;
- __u64 num_objects_degraded;
- __u64 num_rd, num_rd_kb, num_wr, num_wr_kb;
+ uint64_t num_bytes; // in bytes
+ uint64_t num_kb; // in KB
+ uint64_t num_objects;
+ uint64_t num_object_clones;
+ uint64_t num_object_copies; // num_objects * num_replicas
+ uint64_t num_objects_missing_on_primary;
+ uint64_t num_objects_degraded;
+ uint64_t num_rd, num_rd_kb, num_wr, num_wr_kb;
};
typedef void *completion_t;
int getxattr(pool_t pool, const std::string& oid, const char *name, bufferlist& bl);
int setxattr(pool_t pool, const std::string& oid, const char *name, bufferlist& bl);
int getxattrs(pool_t pool, const std::string& oid, std::map<std::string, bufferlist>& attrset);
- int stat(pool_t pool, const std::string& oid, __u64 *psize, time_t *pmtime);
+ int stat(pool_t pool, const std::string& oid, uint64_t *psize, time_t *pmtime);
int tmap_update(pool_t pool, const std::string& oid, bufferlist& cmdbl);
std::map<std::string,pool_stat_t>& stats);
int get_fs_stats(statfs_t& result);
- int create_pool(const char *name, __u64 auid=0);
+ int create_pool(const char *name, uint64_t auid=0);
int delete_pool(const pool_t& pool);
- int change_pool_auid(const pool_t& pool, __u64 auid);
+ int change_pool_auid(const pool_t& pool, uint64_t auid);
int snap_create(const pool_t pool, const char *snapname);
int snap_remove(const pool_t pool, const char *snapname);
struct file_object_t {
- __u64 ino, bno;
+ uint64_t ino, bno;
mutable char buf[33];
- file_object_t(__u64 i=0, __u64 b=0) : ino(i), bno(b) {
+ file_object_t(uint64_t i=0, uint64_t b=0) : ino(i), bno(b) {
buf[0] = 0;
}
// snaps
struct snapid_t {
- __u64 val;
- snapid_t(__u64 v=0) : val(v) {}
+ uint64_t val;
+ snapid_t(uint64_t v=0) : val(v) {}
snapid_t operator+=(snapid_t o) { val += o.val; return *this; }
snapid_t operator++() { ++val; return *this; }
- operator __u64() const { return val; }
+ operator uint64_t() const { return val; }
};
inline void encode(snapid_t i, bufferlist &bl) { encode(i.val, bl); }
// some basic types
// NOTE: these must match ceph_fs.h typedefs
-typedef __u64 tid_t; // transaction id
-typedef __u64 version_t;
+typedef uint64_t tid_t; // transaction id
+typedef uint64_t version_t;
typedef __u32 epoch_t; // map epoch (32bits -> 13 epochs/second for 10 years)
#define O_LAZY 01000000
// identify individual mount clients by 64bit value
struct client_t {
- __s64 v;
+ int64_t v;
- client_t(__s64 _v = -2) : v(_v) {}
+ client_t(int64_t _v = -2) : v(_v) {}
void encode(bufferlist& bl) const {
::encode(v, bl);
static inline bool operator>(const client_t& l, const client_t& r) { return l.v > r.v; }
static inline bool operator>=(const client_t& l, const client_t& r) { return l.v >= r.v; }
-static inline bool operator>=(const client_t& l, __s64 o) { return l.v >= o; }
-static inline bool operator<(const client_t& l, __s64 o) { return l.v < o; }
+static inline bool operator>=(const client_t& l, int64_t o) { return l.v >= o; }
+static inline bool operator<(const client_t& l, int64_t o) { return l.v < o; }
inline ostream& operator<<(ostream& out, const client_t& c) {
return out << c.v;
// --------------------------------------
// ino
-typedef __u64 _inodeno_t;
+typedef uint64_t _inodeno_t;
struct inodeno_t {
_inodeno_t val;
inline ostream& operator<<(ostream& out, const prettybyte_t& b)
{
- __u64 bump_after = 100;
+ uint64_t bump_after = 100;
if (b.v > bump_after << 60)
return out << (b.v >> 60) << " EB";
if (b.v > bump_after << 50)
inline ostream& operator<<(ostream& out, const kb_t& kb)
{
- __u64 bump_after = 100;
+ uint64_t bump_after = 100;
if (kb.v > bump_after << 40)
return out << (kb.v >> 40) << " PB";
if (kb.v > bump_after << 30)
}
// snaps
- int snap_list(PoolCtx *pool, vector<__u64> *snaps);
- int snap_lookup(PoolCtx *pool, const char *name, __u64 *snapid);
- int snap_get_name(PoolCtx *pool, __u64 snapid, std::string *s);
- int snap_get_stamp(PoolCtx *pool, __u64 snapid, time_t *t);
+ int snap_list(PoolCtx *pool, vector<uint64_t> *snaps);
+ int snap_lookup(PoolCtx *pool, const char *name, uint64_t *snapid);
+ int snap_get_name(PoolCtx *pool, uint64_t snapid, std::string *s);
+ int snap_get_stamp(PoolCtx *pool, uint64_t snapid, time_t *t);
int snap_create(const rados_pool_t pool, const char* snapname);
int snap_remove(const rados_pool_t pool, const char* snapname);
int write_full(PoolCtx& pool, const object_t& oid, bufferlist& bl);
int read(PoolCtx& pool, const object_t& oid, off_t off, bufferlist& bl, size_t len);
int remove(PoolCtx& pool, const object_t& oid);
- int stat(PoolCtx& pool, const object_t& oid, __u64 *psize, time_t *pmtime);
+ int stat(PoolCtx& pool, const object_t& oid, uint64_t *psize, time_t *pmtime);
int tmap_update(PoolCtx& pool, const object_t& oid, bufferlist& cmdbl);
int exec(PoolCtx& pool, const object_t& oid, const char *cls, const char *method, bufferlist& inbl, bufferlist& outbl);
return reply;
}
-int RadosClient::snap_list(PoolCtx *pool, vector<__u64> *snaps)
+int RadosClient::snap_list(PoolCtx *pool, vector<uint64_t> *snaps)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(pool->poolid);
return 0;
}
-int RadosClient::snap_lookup(PoolCtx *pool, const char *name, __u64 *snapid)
+int RadosClient::snap_lookup(PoolCtx *pool, const char *name, uint64_t *snapid)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(pool->poolid);
return -ENOENT;
}
-int RadosClient::snap_get_name(PoolCtx *pool, __u64 snapid, std::string *s)
+int RadosClient::snap_get_name(PoolCtx *pool, uint64_t snapid, std::string *s)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(pool->poolid);
return 0;
}
-int RadosClient::snap_get_stamp(PoolCtx *pool, __u64 snapid, time_t *t)
+int RadosClient::snap_get_stamp(PoolCtx *pool, uint64_t snapid, time_t *t)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(pool->poolid);
return bl.length();
}
-int RadosClient::stat(PoolCtx& pool, const object_t& oid, __u64 *psize, time_t *pmtime)
+int RadosClient::stat(PoolCtx& pool, const object_t& oid, uint64_t *psize, time_t *pmtime)
{
SnapContext snapc;
bool done;
int r;
Context *onack = new C_SafeCond(&mylock, &cond, &done, &r);
- __u64 size;
+ uint64_t size;
utime_t mtime;
if (!psize)
return r;
}
-int Rados::create_pool(const char *name, __u64 auid)
+int Rados::create_pool(const char *name, uint64_t auid)
{
string str(name);
if (!client)
return ((RadosClient *)client)->delete_pool(pool);
}
-int Rados::change_pool_auid(const rados_pool_t& pool, __u64 auid)
+int Rados::change_pool_auid(const rados_pool_t& pool, uint64_t auid)
{
if (!client) return -EINVAL;
return ((RadosClient *)client)->change_pool_auid(pool, auid);
return ((RadosClient *)client)->setxattr(*(RadosClient::PoolCtx *)pool, oid, name, bl);
}
-int Rados::stat(rados_pool_t pool, const string& o, __u64 *psize, time_t *pmtime)
+int Rados::stat(rados_pool_t pool, const string& o, uint64_t *psize, time_t *pmtime)
{
if (!client)
return -EINVAL;
return radosp->create_pool(sname);
}
-extern "C" int rados_create_pool_with_auid(const char *name, __u64 auid)
+extern "C" int rados_create_pool_with_auid(const char *name, uint64_t auid)
{
string sname(name);
return radosp->create_pool(sname, auid);
return radosp->delete_pool(pool);
}
-extern "C" int rados_change_pool_auid(const rados_pool_t pool, __u64 auid)
+extern "C" int rados_change_pool_auid(const rados_pool_t pool, uint64_t auid)
{
return radosp->change_pool_auid(pool, auid);
}
extern "C" int rados_snap_list(rados_pool_t pool, rados_snap_t *snaps, int maxlen)
{
RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
- vector<__u64> snapvec;
+ vector<uint64_t> snapvec;
int r = radosp->snap_list(ctx, &snapvec);
if (r < 0)
return r;
extern "C" int rados_snap_lookup(rados_pool_t pool, const char *name, rados_snap_t *id)
{
RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
- return radosp->snap_lookup(ctx, name, (__u64 *)id);
+ return radosp->snap_lookup(ctx, name, (uint64_t *)id);
}
extern "C" int rados_snap_get_name(rados_pool_t pool, rados_snap_t id, char *name, int maxlen)
return radosp->setxattr(*ctx, oid, name, bl);
}
-extern "C" int rados_stat(rados_pool_t pool, const char *o, __u64 *psize, time_t *pmtime)
+extern "C" int rados_stat(rados_pool_t pool, const char *o, uint64_t *psize, time_t *pmtime)
{
RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
object_t oid(o);
// server
-void AnchorServer::_prepare(bufferlist &bl, __u64 reqid, int bymds)
+void AnchorServer::_prepare(bufferlist &bl, uint64_t reqid, int bymds)
{
bufferlist::iterator p = bl.begin();
__u32 what;
void dump();
// server bits
- void _prepare(bufferlist &bl, __u64 reqid, int bymds);
+ void _prepare(bufferlist &bl, uint64_t reqid, int bymds);
void _commit(version_t tid);
void _rollback(version_t tid);
void handle_query(MMDSTableRequest *m);
}
-void CDentry::add_waiter(__u64 tag, Context *c)
+void CDentry::add_waiter(uint64_t tag, Context *c)
{
// wait on the directory?
if (tag & (WAIT_UNFREEZE|WAIT_SINGLEAUTH)) {
// -- wait --
//static const int WAIT_LOCK_OFFSET = 8;
- void add_waiter(__u64 tag, Context *c);
+ void add_waiter(uint64_t tag, Context *c);
static const int EXPORT_NONCE = 1;
-void CDir::add_waiter(__u64 tag, Context *c)
+void CDir::add_waiter(uint64_t tag, Context *c)
{
// hierarchical?
/* NOTE: this checks dentry waiters too */
-void CDir::take_waiting(__u64 mask, list<Context*>& ls)
+void CDir::take_waiting(uint64_t mask, list<Context*>& ls)
{
if ((mask & WAIT_DENTRY) && waiting_on_dentry.size()) {
// take each each dentry waiter
}
-void CDir::finish_waiting(__u64 mask, int result)
+void CDir::finish_waiting(uint64_t mask, int result)
{
dout(11) << "finish_waiting mask " << hex << mask << dec << " result " << result << " on " << *this << dendl;
// -- wait masks --
- static const __u64 WAIT_DENTRY = (1<<0); // wait for item to be in cache
- static const __u64 WAIT_COMPLETE = (1<<1); // wait for complete dir contents
- static const __u64 WAIT_FROZEN = (1<<2); // auth pins removed
+ static const uint64_t WAIT_DENTRY = (1<<0); // wait for item to be in cache
+ static const uint64_t WAIT_COMPLETE = (1<<1); // wait for complete dir contents
+ static const uint64_t WAIT_FROZEN = (1<<2); // auth pins removed
static const int WAIT_DNLOCK_OFFSET = 4;
- static const __u64 WAIT_ANY_MASK = (0xffffffff);
- static const __u64 WAIT_ATFREEZEROOT = (WAIT_UNFREEZE);
- static const __u64 WAIT_ATSUBTREEROOT = (WAIT_SINGLEAUTH);
+ static const uint64_t WAIT_ANY_MASK = (0xffffffff);
+ static const uint64_t WAIT_ATFREEZEROOT = (WAIT_UNFREEZE);
+ static const uint64_t WAIT_ATSUBTREEROOT = (WAIT_SINGLEAUTH);
void take_sub_waiting(list<Context*>& ls); // dentry or ino
- void add_waiter(__u64 mask, Context *c);
- void take_waiting(__u64 mask, list<Context*>& ls); // may include dentry waiters
- void finish_waiting(__u64 mask, int result = 0); // ditto
+ void add_waiter(uint64_t mask, Context *c);
+ void take_waiting(uint64_t mask, list<Context*>& ls); // may include dentry waiters
+ void finish_waiting(uint64_t mask, int result = 0); // ditto
// -- import/export --
CDentry *pdn = get_parent_dn();
if (pdn) {
bufferlist parent(32 + pdn->name.length());
- __u64 ino = pdn->get_dir()->get_inode()->ino();
+ uint64_t ino = pdn->get_dir()->get_inode()->ino();
__u8 v = 1;
::encode(v, parent);
::encode(inode.version, parent);
return false;
}
-void CInode::add_waiter(__u64 tag, Context *c)
+void CInode::add_waiter(uint64_t tag, Context *c)
{
dout(10) << "add_waiter tag " << tag
<< " !ambig " << !state_test(STATE_AMBIGUOUSAUTH)
m->head.time_warp_seq = i->time_warp_seq;
// max_size is min of projected, actual.
- __u64 oldms = oi->client_ranges.count(client) ? oi->client_ranges[client].last : 0;
- __u64 newms = pi->client_ranges.count(client) ? pi->client_ranges[client].last : 0;
+ uint64_t oldms = oi->client_ranges.count(client) ? oi->client_ranges[client].last : 0;
+ uint64_t newms = pi->client_ranges.count(client) ? pi->client_ranges[client].last : 0;
m->head.max_size = MIN(oldms, newms);
i = pauth ? pi:oi;
static const int STATE_DIRTYPARENT = (1<<14);
// -- waiters --
- static const __u64 WAIT_DIR = (1<<0);
- static const __u64 WAIT_ANCHORED = (1<<1);
- static const __u64 WAIT_UNANCHORED = (1<<2);
- static const __u64 WAIT_FROZEN = (1<<3);
- static const __u64 WAIT_TRUNC = (1<<4);
+ static const uint64_t WAIT_DIR = (1<<0);
+ static const uint64_t WAIT_ANCHORED = (1<<1);
+ static const uint64_t WAIT_UNANCHORED = (1<<2);
+ static const uint64_t WAIT_FROZEN = (1<<3);
+ static const uint64_t WAIT_TRUNC = (1<<4);
- static const __u64 WAIT_ANY_MASK = (__u64)(-1);
+ static const uint64_t WAIT_ANY_MASK = (uint64_t)(-1);
// misc
static const int EXPORT_NONCE = 1; // nonce given to replicas created by export
// -- waiting --
- void add_waiter(__u64 tag, Context *c);
+ void add_waiter(uint64_t tag, Context *c);
// -- encode/decode helpers --
CInode *inode;
client_t client;
- __u64 cap_id;
+ uint64_t cap_id;
__u32 _wanted; // what the client wants (ideally)
xlist<Capability*>::item item_session_caps;
xlist<Capability*>::item item_snaprealm_caps;
- Capability(CInode *i, __u64 id, client_t c) :
+ Capability(CInode *i, uint64_t id, client_t c) :
inode(i), client(c),
cap_id(id),
_wanted(0),
void set_last_issue() { last_issue = last_sent; }
void set_last_issue_stamp(utime_t t) { last_issue_stamp = t; }
- void set_cap_id(__u64 i) { cap_id = i; }
- __u64 get_cap_id() { return cap_id; }
+ void set_cap_id(uint64_t i) { cap_id = i; }
+ uint64_t get_cap_id() { return cap_id; }
//ceph_seq_t get_last_issue() { return last_issue; }
};
-void Locker::calc_new_client_ranges(CInode *in, __u64 size, map<client_t,byte_range_t>& new_ranges)
+void Locker::calc_new_client_ranges(CInode *in, uint64_t size, map<client_t,byte_range_t>& new_ranges)
{
inode_t *latest = in->get_projected_inode();
- __u64 ms = ROUND_UP_TO((size+1)<<1, latest->get_layout_size_increment());
+ uint64_t ms = ROUND_UP_TO((size+1)<<1, latest->get_layout_size_increment());
// increase ranges as appropriate.
// shrink to 0 if no WR|BUFFER caps issued.
if ((p->second->issued() | p->second->wanted()) & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_BUFFER)) {
new_ranges[p->first].first = 0;
if (latest->client_ranges.count(p->first)) {
- __u64 last = latest->client_ranges[p->first].last;
+ uint64_t last = latest->client_ranges[p->first].last;
new_ranges[p->first].last = MAX(ms, last);
} else
new_ranges[p->first].last = ms;
}
bool Locker::check_inode_max_size(CInode *in, bool force_wrlock,
- bool update_size, __u64 new_size, utime_t new_mtime)
+ bool update_size, uint64_t new_size, utime_t new_mtime)
{
assert(in->is_auth());
inode_t *latest = in->get_projected_inode();
map<client_t,byte_range_t> new_ranges;
- __u64 size = latest->size;
+ uint64_t size = latest->size;
if (update_size)
size = new_size;
bool new_max = false;
}
void Locker::process_cap_update(MDRequest *mdr, client_t client,
- inodeno_t ino, __u64 cap_id, int caps, int wanted,
+ inodeno_t ino, uint64_t cap_id, int caps, int wanted,
int seq, int issue_seq, int mseq,
const nstring& dname)
{
}
-static __u64 calc_bounding(__u64 t)
+static uint64_t calc_bounding(uint64_t t)
{
t |= t >> 1;
t |= t >> 2;
inode_t *latest = in->get_projected_inode();
// increase or zero max_size?
- __u64 size = m->get_size();
+ uint64_t size = m->get_size();
bool change_max = false;
uint64_t old_max = latest->client_ranges.count(client) ? latest->client_ranges[client].last : 0;
uint64_t new_max = old_max;
dout(10) << "handle_client_cap_release " << *m << dendl;
for (vector<ceph_mds_cap_item>::iterator p = m->caps.begin(); p != m->caps.end(); p++) {
- inodeno_t ino((__u64)p->ino);
+ inodeno_t ino((uint64_t)p->ino);
CInode *in = mdcache->get_inode(ino);
if (!in) {
dout(10) << " missing ino " << ino << dendl;
// caps
void process_cap_update(MDRequest *mdr, client_t client,
- inodeno_t ino, __u64 cap_id, int caps, int wanted,
+ inodeno_t ino, uint64_t cap_id, int caps, int wanted,
int seq, int issue_seq, int mseq,
const nstring& dname);
void kick_cap_releases(MDRequest *mdr);
void file_update_finish(CInode *in, Mutation *mut, bool share, client_t client, Capability *cap,
MClientCaps *ack);
public:
- void calc_new_client_ranges(CInode *in, __u64 size, map<client_t,byte_range_t>& new_ranges);
- bool check_inode_max_size(CInode *in, bool force_wrlock=false, bool update_size=false, __u64 newsize=0,
+ void calc_new_client_ranges(CInode *in, uint64_t size, map<client_t,byte_range_t>& new_ranges);
+ bool check_inode_max_size(CInode *in, bool force_wrlock=false, bool update_size=false, uint64_t newsize=0,
utime_t mtime=utime_t());
void share_inode_max_size(CInode *in);
struct C_MDC_Recover : public Context {
MDCache *mdc;
CInode *in;
- __u64 size;
+ uint64_t size;
utime_t mtime;
C_MDC_Recover(MDCache *m, CInode *i) : mdc(m), in(i), size(0) {}
void finish(int r) {
}
}
-void MDCache::_recovered(CInode *in, int r, __u64 size, utime_t mtime)
+void MDCache::_recovered(CInode *in, int r, uint64_t size, utime_t mtime)
{
dout(10) << "_recovered r=" << r << " size=" << in->inode.size << " mtime=" << in->inode.mtime
<< " for " << *in << dendl;
assert(in->last == CEPH_NOSNAP);
}
- __u64 period = in->inode.layout.fl_object_size * in->inode.layout.fl_stripe_count;
- __u64 cur_max_size = in->inode.get_max_size();
- __u64 to = MAX(in->inode.size, cur_max_size);
- __u64 num = (to + period - 1) / period;
+ uint64_t period = in->inode.layout.fl_object_size * in->inode.layout.fl_stripe_count;
+ uint64_t cur_max_size = in->inode.get_max_size();
+ uint64_t to = MAX(in->inode.size, cur_max_size);
+ uint64_t num = (to + period - 1) / period;
dout(10) << "purge_stray 0~" << to << " objects 0~" << num << " snapc " << snapc << " on " << *in << dendl;
if (to)
mds->filer->purge_range(in->inode.ino, &in->inode.layout, *snapc,
bool was_link_merge;
map<client_t,entity_inst_t> imported_client_map;
- map<client_t,__u64> sseq_map;
+ map<client_t,uint64_t> sseq_map;
map<CInode*, map<client_t,Capability::Export> > cap_imports;
// for snaps
}
// -- client caps --
- __u64 last_cap_id;
+ uint64_t last_cap_id;
void remove_client_cap(CInode *in, client_t client);
void rejoin_recovered_caps(inodeno_t ino, client_t client, cap_reconnect_t& icr,
int frommds=-1) {
cap_imports[ino][client][frommds] = icr.capinfo;
- cap_import_paths[ino] = filepath(icr.path, (__u64)icr.capinfo.pathbase);
+ cap_import_paths[ino] = filepath(icr.path, (uint64_t)icr.capinfo.pathbase);
}
ceph_mds_cap_reconnect *get_replay_cap_reconnect(inodeno_t ino, client_t client) {
if (cap_imports.count(ino) &&
void start_files_to_recover(vector<CInode*>& recover_q, vector<CInode*>& check_q);
void do_file_recover();
- void _recovered(CInode *in, int r, __u64 size, utime_t mtime);
+ void _recovered(CInode *in, int r, uint64_t size, utime_t mtime);
void purge_prealloc_ino(inodeno_t ino, Context *fin);
return segments.empty() ? 0:segments.rbegin()->second;
}
- LogSegment *get_segment(__u64 off) {
+ LogSegment *get_segment(uint64_t off) {
if (segments.count(off))
return segments[off];
return NULL;
<< "failed <" << failed << ">\n"
<< "stopped <" << stopped << ">\n";
- multimap< pair<unsigned,unsigned>, __u64 > foo;
- for (map<__u64,mds_info_t>::iterator p = mds_info.begin();
+ multimap< pair<unsigned,unsigned>, uint64_t > foo;
+ for (map<uint64_t,mds_info_t>::iterator p = mds_info.begin();
p != mds_info.end();
p++)
- foo.insert(pair<pair<unsigned,unsigned>,__u64>(pair<unsigned,unsigned>(p->second.rank, p->second.inc-1), p->first));
+ foo.insert(pair<pair<unsigned,unsigned>,uint64_t>(pair<unsigned,unsigned>(p->second.rank, p->second.inc-1), p->first));
- for (multimap< pair<unsigned,unsigned>, __u64 >::iterator p = foo.begin();
+ for (multimap< pair<unsigned,unsigned>, uint64_t >::iterator p = foo.begin();
p != foo.end();
p++) {
mds_info_t& info = mds_info[p->second];
void MDSMap::print_summary(ostream& out)
{
map<string,int> by_state;
- for (map<__u64,mds_info_t>::iterator p = mds_info.begin();
+ for (map<uint64_t,mds_info_t>::iterator p = mds_info.begin();
p != mds_info.end();
p++) {
string s = ceph_mds_state_name(p->second.state);
static const int STATE_STOPPING = CEPH_MDS_STATE_STOPPING; // up, exporting metadata (-> standby or out)
struct mds_info_t {
- __u64 global_id;
+ uint64_t global_id;
string name;
int32_t rank;
int32_t inc;
__u32 session_timeout;
__u32 session_autoclose;
- __u64 max_file_size;
+ uint64_t max_file_size;
vector<__u32> data_pg_pools; // file data pg_pools available to clients (via an ioctl). first is the default.
__u32 cas_pg_pool; // where CAS objects go
set<int32_t> in; // currently defined cluster
map<int32_t,int32_t> inc; // most recent incarnation.
set<int32_t> failed, stopped; // which roles are failed or stopped
- map<int32_t,__u64> up; // who is in those roles
- map<__u64,mds_info_t> mds_info;
+ map<int32_t,uint64_t> up; // who is in those roles
+ map<uint64_t,mds_info_t> mds_info;
public:
CompatSet compat;
utime_t get_session_timeout() {
return utime_t(session_timeout,0);
}
- __u64 get_max_filesize() { return max_file_size; }
+ uint64_t get_max_filesize() { return max_file_size; }
epoch_t get_epoch() const { return epoch; }
void inc_epoch() { epoch++; }
__u32 get_cas_pg_pool() const { return cas_pg_pool; }
__u32 get_metadata_pg_pool() const { return metadata_pg_pool; }
- const map<__u64,mds_info_t>& get_mds_info() { return mds_info; }
- const mds_info_t& get_mds_info_gid(__u64 gid) {
+ const map<uint64_t,mds_info_t>& get_mds_info() { return mds_info; }
+ const mds_info_t& get_mds_info_gid(uint64_t gid) {
assert(mds_info.count(gid));
return mds_info[gid];
}
}
unsigned get_num_mds(int state) {
unsigned n = 0;
- for (map<__u64,mds_info_t>::const_iterator p = mds_info.begin();
+ for (map<uint64_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p)
if (p->second.state == state) ++n;
s = in;
}
void get_up_mds_set(set<int>& s) {
- for (map<int32_t,__u64>::const_iterator p = up.begin();
+ for (map<int32_t,uint64_t>::const_iterator p = up.begin();
p != up.end();
++p)
s.insert(p->first);
}
void get_recovery_mds_set(set<int>& s) {
s = failed;
- for (map<__u64,mds_info_t>::const_iterator p = mds_info.begin();
+ for (map<uint64_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p)
if (p->second.state >= STATE_REPLAY && p->second.state <= STATE_STOPPING)
s.insert(p->second.rank);
}
void get_mds_set(set<int>& s, int state) {
- for (map<__u64,mds_info_t>::const_iterator p = mds_info.begin();
+ for (map<uint64_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p)
if (p->second.state == state)
int get_random_up_mds() {
if (up.empty())
return -1;
- map<int32_t,__u64>::iterator p = up.begin();
+ map<int32_t,uint64_t>::iterator p = up.begin();
for (int n = rand() % up.size(); n; n--)
p++;
return p->first;
}
- __u64 find_standby_for(int mds, string& name) {
- for (map<__u64,mds_info_t>::const_iterator p = mds_info.begin();
+ uint64_t find_standby_for(int mds, string& name) {
+ for (map<uint64_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p) {
if (p->second.rank == -1 &&
return p->first;
}
}
- for (map<__u64,mds_info_t>::const_iterator p = mds_info.begin();
+ for (map<uint64_t,mds_info_t>::const_iterator p = mds_info.begin();
p != mds_info.end();
++p) {
if (p->second.rank == -1 &&
bool is_stopped(int m) { return stopped.count(m); }
bool is_dne(int m) { return in.count(m) == 0; }
- bool is_dne_gid(__u64 gid) { return mds_info.count(gid) == 0; }
+ bool is_dne_gid(uint64_t gid) { return mds_info.count(gid) == 0; }
int get_state(int m) { return up.count(m) ? mds_info[up[m]].state : 0; }
- int get_state_gid(__u64 gid) { return mds_info.count(gid) ? mds_info[gid].state : 0; }
+ int get_state_gid(uint64_t gid) { return mds_info.count(gid) ? mds_info[gid].state : 0; }
mds_info_t& get_info(int m) { assert(up.count(m)); return mds_info[up[m]]; }
- mds_info_t& get_info_gid(__u64 gid) { assert(mds_info.count(gid)); return mds_info[gid]; }
+ mds_info_t& get_info_gid(uint64_t gid) { assert(mds_info.count(gid)); return mds_info[gid]; }
bool is_boot(int m) { return get_state(m) == STATE_BOOT; }
bool is_creating(int m) { return get_state(m) == STATE_CREATING; }
bool is_stopping(int m) { return get_state(m) == STATE_STOPPING; }
bool is_clientreplay_or_active_or_stopping(int m) { return is_clientreplay(m) || is_active(m) || is_stopping(m); }
- bool is_laggy_gid(__u64 gid) { return mds_info.count(gid) && mds_info[gid].laggy(); }
+ bool is_laggy_gid(uint64_t gid) { return mds_info.count(gid) && mds_info[gid].laggy(); }
// cluster states
return false;
}
- int get_rank_gid(__u64 gid) {
+ int get_rank_gid(uint64_t gid) {
if (mds_info.count(gid))
return mds_info[gid].rank;
return -1;
assert(m->table == table);
version_t tid = m->get_tid();
- __u64 reqid = m->reqid;
+ uint64_t reqid = m->reqid;
switch (m->op) {
case TABLESERVER_OP_QUERY_REPLY:
void MDSTableClient::_prepare(bufferlist& mutation, version_t *ptid, bufferlist *pbl,
Context *onfinish)
{
- __u64 reqid = ++last_reqid;
+ uint64_t reqid = ++last_reqid;
dout(10) << "_prepare " << reqid << dendl;
// send message
resend_queries();
// prepares.
- for (map<__u64, _pending_prepare>::iterator p = pending_prepare.begin();
+ for (map<uint64_t, _pending_prepare>::iterator p = pending_prepare.begin();
p != pending_prepare.end();
p++) {
dout(10) << "resending " << p->first << dendl;
MDS *mds;
int table;
- __u64 last_reqid;
+ uint64_t last_reqid;
// prepares
struct _pending_prepare {
_pending_prepare() : onfinish(0), ptid(0), pbl(0) {}
};
- map<__u64, _pending_prepare> pending_prepare;
+ map<uint64_t, _pending_prepare> pending_prepare;
// pending commits
map<version_t, LogSegment*> pending_commit;
* pending mutation state in the table.
*/
struct _pending {
- __u64 reqid;
+ uint64_t reqid;
__s32 mds;
version_t tid;
void encode(bufferlist& bl) const {
public:
virtual void handle_query(MMDSTableRequest *m) = 0;
- virtual void _prepare(bufferlist &bl, __u64 reqid, int bymds) = 0;
+ virtual void _prepare(bufferlist &bl, uint64_t reqid, int bymds) = 0;
virtual void _commit(version_t tid) = 0;
virtual void _rollback(version_t tid) = 0;
virtual void _server_update(bufferlist& bl) { assert(0); }
- void _note_prepare(int mds, __u64 reqid) {
+ void _note_prepare(int mds, uint64_t reqid) {
pending_for_mds[version].mds = mds;
pending_for_mds[version].reqid = reqid;
pending_for_mds[version].tid = version;
}
- void _note_commit(__u64 tid) {
+ void _note_commit(uint64_t tid) {
pending_for_mds.erase(tid);
}
- void _note_rollback(__u64 tid) {
+ void _note_rollback(uint64_t tid) {
pending_for_mds.erase(tid);
}
int from;
public:
map<client_t,entity_inst_t> imported_client_map;
- map<client_t,__u64> sseqmap;
+ map<client_t,uint64_t> sseqmap;
C_MDS_ImportDirLoggedStart(Migrator *m, CDir *d, int f) :
migrator(m), dir(d), from(f) {
void Migrator::import_logged_start(CDir *dir, int from,
map<client_t,entity_inst_t>& imported_client_map,
- map<client_t,__u64>& sseqmap)
+ map<client_t,uint64_t>& sseqmap)
{
dout(7) << "import_logged " << *dir << dendl;
public:
map<CInode*, map<client_t,Capability::Export> > cap_imports;
map<client_t,entity_inst_t> client_map;
- map<client_t,__u64> sseqmap;
+ map<client_t,uint64_t> sseqmap;
C_M_LoggedImportCaps(Migrator *m, CInode *i, int f) : migrator(m), in(i), from(f) {}
void finish(int r) {
int from,
map<CInode*, map<client_t,Capability::Export> >& cap_imports,
map<client_t,entity_inst_t>& client_map,
- map<client_t,__u64>& sseqmap)
+ map<client_t,uint64_t>& sseqmap)
{
dout(10) << "logged_import_caps on " << *in << dendl;
void import_notify_abort(CDir *dir, set<CDir*>& bounds);
void import_logged_start(CDir *dir, int from,
map<client_t,entity_inst_t> &imported_client_map,
- map<client_t,__u64>& sseqmap);
+ map<client_t,uint64_t>& sseqmap);
void handle_export_finish(MExportDirFinish *m);
public:
void import_finish(CDir *dir);
int from,
map<CInode*, map<client_t,Capability::Export> >& cap_imports,
map<client_t,entity_inst_t>& client_map,
- map<client_t,__u64>& sseqmap);
+ map<client_t,uint64_t>& sseqmap);
friend class C_MDS_ImportDirLoggedStart;
class C_MDS_session_finish : public Context {
MDS *mds;
Session *session;
- __u64 state_seq;
+ uint64_t state_seq;
bool open;
version_t cmapv;
interval_set<inodeno_t> inos;
version_t inotablev;
public:
- C_MDS_session_finish(MDS *m, Session *se, __u64 sseq, bool s, version_t mv) :
+ C_MDS_session_finish(MDS *m, Session *se, uint64_t sseq, bool s, version_t mv) :
mds(m), session(se), state_seq(sseq), open(s), cmapv(mv), inotablev(0) { }
- C_MDS_session_finish(MDS *m, Session *se, __u64 sseq, bool s, version_t mv, interval_set<inodeno_t>& i, version_t iv) :
+ C_MDS_session_finish(MDS *m, Session *se, uint64_t sseq, bool s, version_t mv, interval_set<inodeno_t>& i, version_t iv) :
mds(m), session(se), state_seq(sseq), open(s), cmapv(mv), inos(i), inotablev(iv) { }
void finish(int r) {
assert(r == 0);
return;
}
- __u64 sseq = 0;
+ uint64_t sseq = 0;
switch (m->get_op()) {
case CEPH_SESSION_REQUEST_OPEN:
if (session->is_opening() ||
}
}
-void Server::_session_logged(Session *session, __u64 state_seq, bool open, version_t pv,
+void Server::_session_logged(Session *session, uint64_t state_seq, bool open, version_t pv,
interval_set<inodeno_t>& inos, version_t piv)
{
dout(10) << "_session_logged " << session->inst << " state_seq " << state_seq << " " << (open ? "open":"close")
}
version_t Server::prepare_force_open_sessions(map<client_t,entity_inst_t>& cm,
- map<client_t,__u64>& sseqmap)
+ map<client_t,uint64_t>& sseqmap)
{
version_t pv = ++mds->sessionmap.projected;
dout(10) << "prepare_force_open_sessions " << pv
}
void Server::finish_force_open_sessions(map<client_t,entity_inst_t>& cm,
- map<client_t,__u64>& sseqmap)
+ map<client_t,uint64_t>& sseqmap)
{
/*
* FIXME: need to carefully consider the race conditions between a
assert(session);
if (sseqmap.count(p->first)) {
- __u64 sseq = sseqmap[p->first];
+ uint64_t sseq = sseqmap[p->first];
if (session->get_state_seq() != sseq) {
dout(10) << "force_open_sessions skipping changed " << session->inst << dendl;
} else {
session->is_killing() ||
session->is_closed())
continue;
- __u64 sseq = mds->sessionmap.set_state(session, Session::STATE_CLOSING);
+ uint64_t sseq = mds->sessionmap.set_state(session, Session::STATE_CLOSING);
version_t pv = ++mds->sessionmap.projected;
mdlog->start_submit_entry(new ESession(session->inst, false, pv),
new C_MDS_session_finish(mds, session, sseq, false, pv));
session->is_stale()) &&
!session->is_importing()) {
dout(10) << "kill_session " << session << dendl;
- __u64 sseq = mds->sessionmap.set_state(session, Session::STATE_KILLING);
+ uint64_t sseq = mds->sessionmap.set_state(session, Session::STATE_KILLING);
version_t pv = ++mds->sessionmap.projected;
mdlog->start_submit_entry(new ESession(session->inst, false, pv),
new C_MDS_session_finish(mds, session, sseq, false, pv));
dout(7) << " client had no session, removing from session map" << dendl;
assert(session); // ?
version_t pv = ++mds->sessionmap.projected;
- __u64 sseq = session->get_state_seq();
+ uint64_t sseq = session->get_state_seq();
mdlog->start_submit_entry(new ESession(session->inst, false, pv),
new C_MDS_session_finish(mds, session, sseq, false, pv));
mdlog->flush();
<< m->get_source_inst() << dendl;
mds->sessionmap.set_state(session, Session::STATE_OPENING);
version_t pv = ++mds->sessionmap.projected;
- __u64 sseq = session->get_state_seq();
+ uint64_t sseq = session->get_state_seq();
mdlog->start_submit_entry(new ESession(session->inst, true, pv),
new C_MDS_session_finish(mds, session, sseq, true, pv));
mdlog->flush();
continue;
}
- filepath path(p->second.path, (__u64)p->second.capinfo.pathbase);
+ filepath path(p->second.path, (uint64_t)p->second.capinfo.pathbase);
if ((in && !in->is_auth()) ||
!mds->mdcache->path_is_mine(path)) {
// not mine.
p != req->releases.end();
p++)
mds->locker->process_cap_update(mdr, client,
- inodeno_t((__u64)p->item.ino), p->item.cap_id,
+ inodeno_t((uint64_t)p->item.ino), p->item.cap_id,
p->item.caps, p->item.wanted,
p->item.seq,
p->item.issue_seq,
// trunc from bigger -> smaller?
inode_t *pi = cur->get_projected_inode();
- __u64 old_size = MAX(pi->size, req->head.args.setattr.old_size);
+ uint64_t old_size = MAX(pi->size, req->head.args.setattr.old_size);
bool truncating_smaller = false;
if (mask & CEPH_SETATTR_SIZE) {
truncating_smaller = req->head.args.setattr.size < old_size;
Session *get_session(Message *m);
void handle_client_session(class MClientSession *m);
- void _session_logged(Session *session, __u64 state_seq,
+ void _session_logged(Session *session, uint64_t state_seq,
bool open, version_t pv, interval_set<inodeno_t>& inos,version_t piv);
version_t prepare_force_open_sessions(map<client_t,entity_inst_t> &cm,
- map<client_t,__u64>& sseqmap);
+ map<client_t,uint64_t>& sseqmap);
void finish_force_open_sessions(map<client_t,entity_inst_t> &cm,
- map<client_t,__u64>& sseqmap);
+ map<client_t,uint64_t>& sseqmap);
void terminate_sessions();
void find_idle_sessions();
void kill_session(Session *session);
void SessionMap::encode(bufferlist& bl)
{
- __u64 pre = -1; // for 0.19 compatibility; we forgot an encoding prefix.
+ uint64_t pre = -1; // for 0.19 compatibility; we forgot an encoding prefix.
::encode(pre, bl);
__u8 struct_v = 2;
void SessionMap::decode(bufferlist::iterator& p)
{
utime_t now = g_clock.now();
- __u64 pre;
+ uint64_t pre;
::decode(pre, p);
- if (pre == (__u64)-1) {
+ if (pre == (uint64_t)-1) {
__u8 struct_v;
::decode(struct_v, p);
assert(struct_v == 2);
private:
int state;
- __u64 state_seq;
+ uint64_t state_seq;
int importing_count;
friend class SessionMap;
public:
int get_state() { return state; }
const char *get_state_name() { return get_state_name(state); }
- __u64 get_state_seq() { return state_seq; }
+ uint64_t get_state_seq() { return state_seq; }
bool is_closed() { return state == STATE_CLOSED; }
bool is_opening() { return state == STATE_OPENING; }
bool is_open() { return state == STATE_OPEN; }
if (by_state[state].empty()) return 0;
return by_state[state].front();
}
- __u64 set_state(Session *session, int s) {
+ uint64_t set_state(Session *session, int s) {
if (session->state != s) {
session->state = s;
session->state_seq++;
// waiting
- static const __u64 WAIT_RD = (1<<0); // to read
- static const __u64 WAIT_WR = (1<<1); // to write
- static const __u64 WAIT_XLOCK = (1<<2); // to xlock (** dup)
- static const __u64 WAIT_STABLE = (1<<2); // for a stable state
- static const __u64 WAIT_REMOTEXLOCK = (1<<3); // for a remote xlock
+ static const uint64_t WAIT_RD = (1<<0); // to read
+ static const uint64_t WAIT_WR = (1<<1); // to write
+ static const uint64_t WAIT_XLOCK = (1<<2); // to xlock (** dup)
+ static const uint64_t WAIT_STABLE = (1<<2); // for a stable state
+ static const uint64_t WAIT_REMOTEXLOCK = (1<<3); // for a remote xlock
static const int WAIT_BITS = 4;
- static const __u64 WAIT_ALL = ((1<<WAIT_BITS)-1);
+ static const uint64_t WAIT_ALL = ((1<<WAIT_BITS)-1);
protected:
void encode_locked_state(bufferlist& bl) {
parent->encode_lock_state(type->type, bl);
}
- void finish_waiters(__u64 mask, int r=0) {
+ void finish_waiters(uint64_t mask, int r=0) {
parent->finish_waiting(mask << get_wait_shift(), r);
}
- void take_waiting(__u64 mask, list<Context*>& ls) {
+ void take_waiting(uint64_t mask, list<Context*>& ls) {
parent->take_waiting(mask << get_wait_shift(), ls);
}
- void add_waiter(__u64 mask, Context *c) {
+ void add_waiter(uint64_t mask, Context *c) {
parent->add_waiter(mask << get_wait_shift(), c);
}
- bool is_waiter_for(__u64 mask) {
+ bool is_waiter_for(uint64_t mask) {
return parent->is_waiter_for(mask << get_wait_shift());
}
// SERVER
-void SnapServer::_prepare(bufferlist &bl, __u64 reqid, int bymds)
+void SnapServer::_prepare(bufferlist &bl, uint64_t reqid, int bymds)
{
bufferlist::iterator p = bl.begin();
__u32 op;
}
// server bits
- void _prepare(bufferlist &bl, __u64 reqid, int bymds);
+ void _prepare(bufferlist &bl, uint64_t reqid, int bymds);
bool _is_prepared(version_t tid);
void _commit(version_t tid);
void _rollback(version_t tid);
// inodes i've truncated
list<inodeno_t> truncate_start; // start truncate
- map<inodeno_t,__u64> truncate_finish; // finished truncate (started in segment blah)
+ map<inodeno_t,uint64_t> truncate_finish; // finished truncate (started in segment blah)
vector<inodeno_t> destroyed_inodes;
// idempotent op(s)
- list<pair<metareqid_t,__u64> > client_reqs;
+ list<pair<metareqid_t,uint64_t> > client_reqs;
public:
void encode(bufferlist& bl) const {
list<metareqid_t> r;
::decode(r, bl);
while (!r.empty()) {
- client_reqs.push_back(pair<metareqid_t,__u64>(r.front(), 0));
+ client_reqs.push_back(pair<metareqid_t,uint64_t>(r.front(), 0));
r.pop_front();
}
}
}
}
- void add_client_req(metareqid_t r, __u64 tid=0) {
- client_reqs.push_back(pair<metareqid_t,__u64>(r, tid));
+ void add_client_req(metareqid_t r, uint64_t tid=0) {
+ client_reqs.push_back(pair<metareqid_t,uint64_t>(r, tid));
}
void add_table_transaction(int table, version_t tid) {
void add_truncate_start(inodeno_t ino) {
truncate_start.push_back(ino);
}
- void add_truncate_finish(inodeno_t ino, __u64 segoff) {
+ void add_truncate_finish(inodeno_t ino, uint64_t segoff) {
truncate_finish[ino] = segoff;
}
struct ETableServer : public LogEvent {
__u16 table;
__s16 op;
- __u64 reqid;
+ uint64_t reqid;
__s32 bymds;
bufferlist mutation;
version_t tid;
version_t version;
ETableServer() : LogEvent(EVENT_TABLESERVER) { }
- ETableServer(int t, int o, __u64 ri, int m, version_t ti, version_t v) :
+ ETableServer(int t, int o, uint64_t ri, int m, version_t ti, version_t v) :
LogEvent(EVENT_TABLESERVER),
table(t), op(o), reqid(ri), bymds(m), tid(ti), version(v) { }
assert(in);
mds->mdcache->add_recovered_truncate(in, logseg);
}
- for (map<inodeno_t,__u64>::iterator p = truncate_finish.begin();
+ for (map<inodeno_t,uint64_t>::iterator p = truncate_finish.begin();
p != truncate_finish.end();
p++) {
LogSegment *ls = mds->mdlog->get_segment(p->second);
}
// client requests
- for (list<pair<metareqid_t, __u64> >::iterator p = client_reqs.begin();
+ for (list<pair<metareqid_t, uint64_t> >::iterator p = client_reqs.begin();
p != client_reqs.end();
++p)
if (p->first.name.is_client()) {
// this frag
utime_t mtime;
- __s64 nfiles; // files
- __s64 nsubdirs; // subdirs
+ int64_t nfiles; // files
+ int64_t nsubdirs; // subdirs
frag_info_t() : version(0), nfiles(0), nsubdirs(0) {}
- __s64 size() const { return nfiles + nsubdirs; }
+ int64_t size() const { return nfiles + nsubdirs; }
void zero() {
*this = frag_info_t();
// this frag + children
utime_t rctime;
- __s64 rbytes;
- __s64 rfiles;
- __s64 rsubdirs;
- __s64 rsize() const { return rfiles + rsubdirs; }
+ int64_t rbytes;
+ int64_t rfiles;
+ int64_t rsubdirs;
+ int64_t rsize() const { return rfiles + rsubdirs; }
- __s64 ranchors; // for dirstat, includes inode's anchored flag.
- __s64 rsnaprealms;
+ int64_t ranchors; // for dirstat, includes inode's anchored flag.
+ int64_t rsnaprealms;
nest_info_t() : version(0),
rbytes(0), rfiles(0), rsubdirs(0),
struct byte_range_t {
- __u64 first, last; // interval client can write to
+ uint64_t first, last; // interval client can write to
void encode(bufferlist &bl) const {
::encode(first, bl);
return layout.fl_object_size * layout.fl_stripe_count;
}
- __u64 get_max_size() const {
- __u64 max = 0;
+ uint64_t get_max_size() const {
+ uint64_t max = 0;
for (map<client_t,byte_range_t>::const_iterator p = client_ranges.begin();
p != client_ranges.end();
++p)
max = p->second.last;
return max;
}
- void set_max_size(__u64 new_max) {
+ void set_max_size(uint64_t new_max) {
if (new_max == 0) {
client_ranges.clear();
} else {
struct metareqid_t {
entity_name_t name;
- __u64 tid;
+ uint64_t tid;
metareqid_t() : tid(0) {}
metareqid_t(entity_name_t n, tid_t t) : name(n), tid(t) {}
};
ceph_mds_cap_reconnect capinfo;
cap_reconnect_t() {}
- cap_reconnect_t(__u64 cap_id, inodeno_t pino, const string& p, int w, int i, uint64_t sz, utime_t mt, utime_t at, inodeno_t sr) :
+ cap_reconnect_t(uint64_t cap_id, inodeno_t pino, const string& p, int w, int i, uint64_t sz, utime_t mt, utime_t at, inodeno_t sr) :
path(p) {
capinfo.cap_id = cap_id;
capinfo.wanted = w;
const static int STATE_REJOINING = (1<<28); // replica has not joined w/ primary copy
// -- wait --
- const static __u64 WAIT_SINGLEAUTH = (1ull<<60);
- const static __u64 WAIT_UNFREEZE = (1ull<<59); // pka AUTHPINNABLE
+ const static uint64_t WAIT_SINGLEAUTH = (1ull<<60);
+ const static uint64_t WAIT_UNFREEZE = (1ull<<59); // pka AUTHPINNABLE
// ============================================
// ---------------------------------------------
// waiting
protected:
- multimap<__u64, Context*> waiting;
+ multimap<uint64_t, Context*> waiting;
public:
- bool is_waiter_for(__u64 mask, __u64 min=0) {
+ bool is_waiter_for(uint64_t mask, uint64_t min=0) {
if (!min) {
min = mask;
while (min & (min-1)) // if more than one bit is set
min &= min-1; // clear LSB
}
- for (multimap<__u64,Context*>::iterator p = waiting.lower_bound(min);
+ for (multimap<uint64_t,Context*>::iterator p = waiting.lower_bound(min);
p != waiting.end();
++p) {
if (p->first & mask) return true;
}
return false;
}
- virtual void add_waiter(__u64 mask, Context *c) {
+ virtual void add_waiter(uint64_t mask, Context *c) {
if (waiting.empty())
get(PIN_WAITER);
- waiting.insert(pair<__u64,Context*>(mask, c));
+ waiting.insert(pair<uint64_t,Context*>(mask, c));
pdout(10,g_conf.debug_mds) << (mdsco_db_line_prefix(this))
<< "add_waiter " << hex << mask << dec << " " << c
<< " on " << *this
<< dendl;
}
- virtual void take_waiting(__u64 mask, list<Context*>& ls) {
+ virtual void take_waiting(uint64_t mask, list<Context*>& ls) {
if (waiting.empty()) return;
- multimap<__u64,Context*>::iterator it = waiting.begin();
+ multimap<uint64_t,Context*>::iterator it = waiting.begin();
while (it != waiting.end()) {
if (it->first & mask) {
ls.push_back(it->second);
if (waiting.empty())
put(PIN_WAITER);
}
- void finish_waiting(__u64 mask, int result = 0) {
+ void finish_waiting(uint64_t mask, int result = 0) {
list<Context*> finished;
take_waiting(mask, finished);
finish_contexts(finished, result);
virtual void set_object_info(MDSCacheObjectInfo &info) { assert(0); }
virtual void encode_lock_state(int type, bufferlist& bl) { assert(0); }
virtual void decode_lock_state(int type, bufferlist& bl) { assert(0); }
- virtual void finish_lock_waiters(int type, __u64 mask, int r=0) { assert(0); }
- virtual void add_lock_waiter(int type, __u64 mask, Context *c) { assert(0); }
- virtual bool is_lock_waiting(int type, __u64 mask) { assert(0); return false; }
+ virtual void finish_lock_waiters(int type, uint64_t mask, int r=0) { assert(0); }
+ virtual void add_lock_waiter(int type, uint64_t mask, Context *c) { assert(0); }
+ virtual bool is_lock_waiting(int type, uint64_t mask) { assert(0); return false; }
virtual void clear_dirty_scattered(int type) { assert(0); }
virtual void finish_scatter_gather_update(int type) { }
#define DOUT_SUBSYS mds
#undef dout_prefix
#define dout_prefix _prefix(mdcache->mds->get_nodeid(), inode, seq, this)
-static ostream& _prefix(int whoami, CInode *inode, __u64 seq, SnapRealm *realm) {
+static ostream& _prefix(int whoami, CInode *inode, uint64_t seq, SnapRealm *realm) {
return *_dout << dbeginl
<< " mds" << whoami
<< ".cache.snaprealm(" << inode->ino()
struct MAuthReply : public Message {
__u32 protocol;
__s32 result;
- __u64 global_id; // if zero, meaningless
+ uint64_t global_id; // if zero, meaningless
cstring result_msg;
bufferlist result_bl;
MAuthReply() : Message(CEPH_MSG_AUTH_REPLY), protocol(0), result(0) {}
- MAuthReply(__u32 p, bufferlist *bl = NULL, int r = 0, __u64 gid=0, const char *msg = 0) :
+ MAuthReply(__u32 p, bufferlist *bl = NULL, int r = 0, uint64_t gid=0, const char *msg = 0) :
Message(CEPH_MSG_AUTH_REPLY),
protocol(p), result(r), global_id(gid),
result_msg(msg) {
inodeno_t get_ino() { return inodeno_t(head.ino); }
inodeno_t get_realm() { return inodeno_t(head.realm); }
- __u64 get_cap_id() { return head.cap_id; }
+ uint64_t get_cap_id() { return head.cap_id; }
- __u64 get_size() { return head.size; }
- __u64 get_max_size() { return head.max_size; }
+ uint64_t get_size() { return head.size; }
+ uint64_t get_max_size() { return head.max_size; }
__u32 get_truncate_seq() { return head.truncate_seq; }
- __u64 get_truncate_size() { return head.truncate_size; }
+ uint64_t get_truncate_size() { return head.truncate_size; }
utime_t get_ctime() { return utime_t(head.ctime); }
utime_t get_mtime() { return utime_t(head.mtime); }
utime_t get_atime() { return utime_t(head.atime); }
int get_migrate_seq() { return head.migrate_seq; }
int get_op() { return head.op; }
- __u64 get_client_tid() { return get_tid(); }
- void set_client_tid(__u64 s) { set_tid(s); }
+ uint64_t get_client_tid() { return get_tid(); }
+ void set_client_tid(uint64_t s) { set_tid(s); }
snapid_t get_snap_follows() { return snapid_t(head.snap_follows); }
void set_snap_follows(snapid_t s) { head.snap_follows = s; }
void set_caps(int c) { head.caps = c; }
void set_wanted(int w) { head.wanted = w; }
- void set_max_size(__u64 ms) { head.max_size = ms; }
+ void set_max_size(uint64_t ms) { head.max_size = ms; }
void set_migrate_seq(unsigned m) { head.migrate_seq = m; }
void set_op(int o) { head.op = o; }
MClientCaps(int op,
inodeno_t ino,
inodeno_t realm,
- __u64 id,
+ uint64_t id,
long seq,
int caps,
int wanted,
}
MClientCaps(int op,
inodeno_t ino, inodeno_t realm,
- __u64 id, int mseq) :
+ uint64_t id, int mseq) :
Message(CEPH_MSG_CLIENT_CAPS) {
memset(&head, 0, sizeof(head));
head.op = op;
snapid_t get_last() { return snapid_t(h.last); }
MClientLease() : Message(CEPH_MSG_CLIENT_LEASE) {}
- MClientLease(int ac, ceph_seq_t seq, int m, __u64 i, __u64 sf, __u64 sl) :
+ MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl) :
Message(CEPH_MSG_CLIENT_LEASE) {
h.action = ac;
h.seq = seq;
h.first = sf;
h.last = sl;
}
- MClientLease(int ac, ceph_seq_t seq, int m, __u64 i, __u64 sf, __u64 sl, const nstring& d) :
+ MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl, const nstring& d) :
Message(CEPH_MSG_CLIENT_LEASE),
dname(d) {
h.action = ac;
<< caps.size() << " caps)";
}
- void add_cap(inodeno_t ino, __u64 cap_id, inodeno_t pathbase, const string& path,
+ void add_cap(inodeno_t ino, uint64_t cap_id, inodeno_t pathbase, const string& path,
int wanted, int issued,
loff_t sz, utime_t mt, utime_t at,
inodeno_t sr) {
unsigned mode, uid, gid, nlink, rdev;
loff_t size, max_size;
version_t truncate_seq;
- __u64 truncate_size;
+ uint64_t truncate_size;
utime_t ctime, mtime, atime;
version_t time_warp_seq;
class MMDSBeacon : public PaxosServiceMessage {
ceph_fsid_t fsid;
- __u64 global_id;
+ uint64_t global_id;
string name;
__u32 state;
public:
MMDSBeacon() : PaxosServiceMessage(MSG_MDS_BEACON, 0) {}
- MMDSBeacon(const ceph_fsid_t &f, __u64 g, string& n, epoch_t les, int st, version_t se) :
+ MMDSBeacon(const ceph_fsid_t &f, uint64_t g, string& n, epoch_t les, int st, version_t se) :
PaxosServiceMessage(MSG_MDS_BEACON, les),
fsid(f), global_id(g), name(n), state(st), seq(se),
standby_for_rank(-1) { }
ceph_fsid_t& get_fsid() { return fsid; }
- __u64 get_global_id() { return global_id; }
+ uint64_t get_global_id() { return global_id; }
string& get_name() { return name; }
epoch_t get_last_epoch_seen() { return version; }
int get_state() { return state; }
class MMDSLoadTargets : public PaxosServiceMessage {
public:
- __u64 global_id;
+ uint64_t global_id;
set<int32_t> targets;
MMDSLoadTargets() : PaxosServiceMessage(MSG_MDS_OFFLOAD_TARGETS, 0) {}
- MMDSLoadTargets(__u64 g, set<int32_t>& mds_targets) :
+ MMDSLoadTargets(uint64_t g, set<int32_t>& mds_targets) :
PaxosServiceMessage(MSG_MDS_OFFLOAD_TARGETS, 0),
global_id(g), targets(mds_targets) {}
public:
__u16 table;
__s16 op;
- __u64 reqid;
+ uint64_t reqid;
bufferlist bl;
MMDSTableRequest() {}
- MMDSTableRequest(int tab, int o, __u64 r, version_t v=0) :
+ MMDSTableRequest(int tab, int o, uint64_t r, version_t v=0) :
Message(MSG_MDS_TABLE_REQUEST),
table(tab), op(o), reqid(r) {
set_tid(v);
void set_mtime(utime_t mt) { head.mtime = mt; }
// ops
- void add_simple_op(int o, __u64 off, __u64 len) {
+ void add_simple_op(int o, uint64_t off, uint64_t len) {
OSDOp osd_op;
osd_op.op.op = o;
osd_op.op.extent.offset = off;
osd_op.op.extent.length = len;
ops.push_back(osd_op);
}
- void write(__u64 off, __u64 len, bufferlist& bl) {
+ void write(uint64_t off, uint64_t len, bufferlist& bl) {
add_simple_op(CEPH_OSD_OP_WRITE, off, len);
data.claim(bl);
header.data_off = off;
data.claim(bl);
header.data_off = 0;
}
- void zero(__u64 off, __u64 len) {
+ void zero(uint64_t off, uint64_t len) {
add_simple_op(CEPH_OSD_OP_ZERO, off, len);
}
- void truncate(__u64 off) {
+ void truncate(uint64_t off) {
add_simple_op(CEPH_OSD_OP_TRUNCATE, off, 0);
}
void remove() {
add_simple_op(CEPH_OSD_OP_DELETE, 0, 0);
}
- void read(__u64 off, __u64 len) {
+ void read(uint64_t off, uint64_t len) {
add_simple_op(CEPH_OSD_OP_READ, off, len);
}
void stat() {
out << "w";
#endif
if (head.snapid != CEPH_NOSNAP)
- out << "@" << snapid_t((__u64)head.snapid);
+ out << "@" << snapid_t((uint64_t)head.snapid);
out << " " << ops;
out << " " << pg_t(head.layout.ol_pgid);
bool noop;
bool old_exists;
- __u64 old_size;
+ uint64_t old_size;
eversion_t old_version;
SnapSet snapset;
map<nstring,bufferptr> attrset;
- interval_set<__u64> data_subset;
- map<sobject_t, interval_set<__u64> > clone_subsets;
+ interval_set<uint64_t> data_subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
virtual void decode_payload() {
bufferlist::iterator p = payload.begin();
int pool;
string name;
int op;
- __u64 auid;
+ uint64_t auid;
MPoolOp() : PaxosServiceMessage(MSG_POOLOP, 0) {}
MPoolOp(const ceph_fsid_t& f, tid_t t, int p, string& n, int o, version_t v) :
set_tid(t);
}
MPoolOp(const ceph_fsid_t& f, tid_t t, int p, string& n,
- int o, __u64 uid, version_t v) :
+ int o, uint64_t uid, version_t v) :
PaxosServiceMessage(MSG_POOLOP, v), fsid(f), pool(p), name(n), op(o),
auid(uid) {
set_tid(t);
#include "include/encoding.h"
struct MRoute : public Message {
- __u64 session_mon_tid;
+ uint64_t session_mon_tid;
Message *msg;
entity_inst_t dest;
MRoute() : Message(MSG_ROUTE), msg(NULL) {}
- MRoute(__u64 t, Message *m, entity_inst_t i) :
+ MRoute(uint64_t t, Message *m, entity_inst_t i) :
Message(MSG_ROUTE), session_mon_tid(t), msg(m), dest(i) {}
- MRoute(__u64 t, bufferlist bl, entity_inst_t i) :
+ MRoute(uint64_t t, bufferlist bl, entity_inst_t i) :
Message(MSG_ROUTE), session_mon_tid(t), dest(i) {
bufferlist::iterator p = bl.begin();
msg = decode_message(p);
public:
version_t version;
__s16 session_mon;
- __u64 session_mon_tid;
+ uint64_t session_mon_tid;
PaxosServiceMessage() : Message(MSG_PAXOS),
version(0), session_mon(-1), session_mon_tid(0) { }
}
try {
- __u64 auid;
+ uint64_t auid;
if (start) {
// new session
proto = s->auth_handler->start_session(entity_name, indata, response_bl, caps_info);
void MDSMonitor::_note_beacon(MMDSBeacon *m)
{
- __u64 gid = m->get_global_id();
+ uint64_t gid = m->get_global_id();
version_t seq = m->get_seq();
dout(15) << "_note_beacon " << *m << " noting time" << dendl;
{
entity_addr_t addr = m->get_orig_source_inst().addr;
int state = m->get_state();
- __u64 gid = m->get_global_id();
+ uint64_t gid = m->get_global_id();
version_t seq = m->get_seq();
MDSMap::mds_info_t info;
bool MDSMonitor::preprocess_offload_targets(MMDSLoadTargets* m)
{
dout(10) << "preprocess_offload_targets " << *m << " from " << m->get_orig_source() << dendl;
- __u64 gid;
+ uint64_t gid;
// check privileges, ignore message if fails
MonSession *session = m->get_session();
// -- this is an update --
dout(12) << "prepare_beacon " << *m << " from " << m->get_orig_source_inst() << dendl;
entity_addr_t addr = m->get_orig_source_inst().addr;
- __u64 gid = m->get_global_id();
+ uint64_t gid = m->get_global_id();
int state = m->get_state();
version_t seq = m->get_seq();
bool MDSMonitor::prepare_offload_targets(MMDSLoadTargets *m)
{
- __u64 gid = m->global_id;
+ uint64_t gid = m->global_id;
if (pending_mdsmap.mds_info.count(gid)) {
dout(10) << "prepare_offload_targets " << gid << " " << m->targets << dendl;
pending_mdsmap.mds_info[gid].export_targets = m->targets;
int who = atoi(m->cmd[2].c_str());
if (mdsmap.is_active(who)) {
r = 0;
- __u64 gid = pending_mdsmap.up[who];
+ uint64_t gid = pending_mdsmap.up[who];
ss << "telling mds" << who << " " << pending_mdsmap.mds_info[gid].addr << " to stop";
pending_mdsmap.mds_info[gid].state = MDSMap::STATE_STOPPING;
} else {
//ss << "mdsmap fsid " << map.fsid << " does not match monitor fsid " << mon->monmap->fsid;
}
else if (m->cmd[1] == "set_state" && m->cmd.size() == 4) {
- __u64 gid = atoi(m->cmd[2].c_str());
+ uint64_t gid = atoi(m->cmd[2].c_str());
int state = atoi(m->cmd[3].c_str());
if (!pending_mdsmap.is_dne_gid(gid)) {
MDSMap::mds_info_t& info = pending_mdsmap.get_info_gid(gid);
string name;
while (pending_mdsmap.is_in(mds))
mds++;
- __u64 newgid = pending_mdsmap.find_standby_for(mds, name);
+ uint64_t newgid = pending_mdsmap.find_standby_for(mds, name);
if (!newgid)
break;
cutoff -= g_conf.mds_beacon_grace;
// make sure last_beacon is fully populated
- for (map<__u64,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
+ for (map<uint64_t,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
p != pending_mdsmap.mds_info.end();
++p) {
if (last_beacon.count(p->first) == 0) {
bool propose_osdmap = false;
- map<__u64, beacon_info_t>::iterator p = last_beacon.begin();
+ map<uint64_t, beacon_info_t>::iterator p = last_beacon.begin();
while (p != last_beacon.end()) {
- __u64 gid = p->first;
+ uint64_t gid = p->first;
utime_t since = p->second.stamp;
- __u64 seq = p->second.seq;
+ uint64_t seq = p->second.seq;
p++;
if (pending_mdsmap.mds_info.count(gid) == 0) {
// are we in?
// and is there a non-laggy standby that can take over for us?
- __u64 sgid;
+ uint64_t sgid;
if (info.rank >= 0 &&
info.state != CEPH_MDS_STATE_STANDBY &&
(sgid = pending_mdsmap.find_standby_for(info.rank, info.name)) != 0) {
set<int>::iterator p = failed.begin();
while (p != failed.end()) {
int f = *p++;
- __u64 sgid;
+ uint64_t sgid;
string name; // FIXME
sgid = pending_mdsmap.find_standby_for(f, name);
if (sgid) {
pending_mdsmap.get_num_mds(MDSMap::STATE_STANDBY) >= pending_mdsmap.get_num_mds()) {
// see which nodes are shadowed
set<int> shadowed;
- map<int, set<__u64> > avail;
- for (map<__u64,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
+ map<int, set<uint64_t> > avail;
+ for (map<uint64_t,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
p != pending_mdsmap.mds_info.end();
p++) {
if (p->second.state == MDSMap::STATE_STANDBY_REPLAY)
continue; // already shadowed.
if (pending_mdsmap.get_state(*p) < MDSMap::STATE_ACTIVE)
continue; // only shadow active mds
- __u64 sgid;
+ uint64_t sgid;
if (avail[*p].size()) {
sgid = *avail[*p].begin();
avail[*p].erase(avail[*p].begin());
dout(7) << "do_stop stopping active mds nodes" << dendl;
print_map(mdsmap);
- map<__u64,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
+ map<uint64_t,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
while (p != pending_mdsmap.mds_info.end()) {
- __u64 gid = p->first;
+ uint64_t gid = p->first;
MDSMap::mds_info_t& info = p->second;
p++;
switch (info.state) {
// beacons
struct beacon_info_t {
utime_t stamp;
- __u64 seq;
+ uint64_t seq;
};
- map<__u64, beacon_info_t> last_beacon;
+ map<uint64_t, beacon_info_t> last_beacon;
public:
MDSMonitor(Monitor *mn, Paxos *p) : PaxosService(mn, p) { }
* only get as much access as they allow you AND you have on your own data.
*
*/
-bool MonCaps::check_privileges(int service, int req_perms, __u64 req_auid)
+bool MonCaps::check_privileges(int service, int req_perms, uint64_t req_auid)
{
if (allow_all) return true; //you're an admin, do anything!
if (req_auid != CEPH_AUTH_UID_DEFAULT && req_auid != auid) {
bool is_rwx(string& token, rwx_t& cap_val);
int get_service_id(string& token);
bool allow_all;
- __u64 auid;
+ uint64_t auid;
public:
MonCaps() : text(), default_action(0),
allow_all(false), auid(CEPH_AUTH_UID_DEFAULT) {}
bool parse(bufferlist::iterator& iter);
rwx_t get_caps(int service);
bool check_privileges(int service, int req_perm,
- __u64 auid=CEPH_AUTH_UID_DEFAULT);
+ uint64_t auid=CEPH_AUTH_UID_DEFAULT);
void set_allow_all(bool allow) { allow_all = allow; }
- void set_auid(__u64 uid) { auid = uid; }
+ void set_auid(uint64_t uid) { auid = uid; }
void encode(bufferlist& bl) const {
::encode(text, bl);
{
dout(10) << "resend_routed_requests" << dendl;
int mon = get_leader();
- for (map<__u64, RoutedRequest*>::iterator p = routed_requests.begin();
+ for (map<uint64_t, RoutedRequest*>::iterator p = routed_requests.begin();
p != routed_requests.end();
p++) {
RoutedRequest *rr = p->second;
{
dout(10) << "remove_session " << s << " " << s->inst << dendl;
assert(!s->closed);
- for (set<__u64>::iterator p = s->routed_request_tids.begin();
+ for (set<uint64_t>::iterator p = s->routed_request_tids.begin();
p != s->routed_request_tids.end();
p++) {
if (routed_requests.count(*p)) {
// request routing
struct RoutedRequest {
- __u64 tid;
+ uint64_t tid;
bufferlist request_bl;
MonSession *session;
session->put();
}
};
- __u64 routed_request_tid;
- map<__u64, RoutedRequest*> routed_requests;
+ uint64_t routed_request_tid;
+ map<uint64_t, RoutedRequest*> routed_requests;
void forward_request_leader(PaxosServiceMessage *req);
void handle_forward(MForward *m);
}
}
else if (m->cmd[1] == "lspools") {
- __u64 uid_pools = 0;
+ uint64_t uid_pools = 0;
if (m->cmd.size() > 2) {
uid_pools = strtol(m->cmd[2].c_str(), NULL, 10);
}
return prepare_new_pool(m->name, session->caps.auid);
}
-int OSDMonitor::prepare_new_pool(string& name, __u64 auid)
+int OSDMonitor::prepare_new_pool(string& name, uint64_t auid)
{
if (osdmap.name_pool.count(name)) {
return -EEXIST;
bool prepare_pool_op_create (MPoolOp *m);
bool prepare_pool_op_delete(MPoolOp *m);
bool prepare_pool_op_auid(MPoolOp *m);
- int prepare_new_pool(string& name, __u64 auid = CEPH_AUTH_UID_DEFAULT);
+ int prepare_new_pool(string& name, uint64_t auid = CEPH_AUTH_UID_DEFAULT);
int prepare_new_pool(MPoolOp *m);
void _pool_op(MPoolOp *m, int replyCode, epoch_t epoch);
utime_t until;
bool closed;
xlist<MonSession*>::item item;
- set<__u64> routed_request_tids;
+ set<uint64_t> routed_request_tids;
MonCaps caps;
uint64_t global_id;
uint64_t notified_global_id;
int get_type() { return header.type; }
void set_type(int t) { header.type = t; }
- __u64 get_tid() { return header.tid; }
- void set_tid(__u64 t) { header.tid = t; }
+ uint64_t get_tid() { return header.tid; }
+ void set_tid(uint64_t t) { header.tid = t; }
unsigned get_seq() { return header.seq; }
void set_seq(unsigned s) { header.seq = s; }
bufferptr bp;
bufferlist authorizer, authorizer_reply;
bool authorizer_valid;
- __u64 feat_missing;
+ uint64_t feat_missing;
// this should roughly mirror pseudocode at
// http://ceph.newdream.net/wiki/Messaging_protocol
goto reply;
}
- feat_missing = get_required_bits() & ~(__u64)connect.features;
+ feat_missing = get_required_bits() & ~(uint64_t)connect.features;
if (feat_missing) {
dout(1) << "peer missing required features " << std::hex << feat_missing << std::dec << dendl;
reply.tag = CEPH_MSGR_TAG_FEATURES;
assert(0);
reply:
- reply.features = ((__u64)connect.features & get_supported_bits()) | get_required_bits();
+ reply.features = ((uint64_t)connect.features & get_supported_bits()) | get_required_bits();
reply.authorizer_len = authorizer_reply.length();
rc = tcp_write(sd, (char*)&reply, sizeof(reply));
if (rc < 0)
}
if (reply.tag == CEPH_MSGR_TAG_READY) {
- __u64 feat_missing = get_required_bits() & ~(__u64)reply.features;
+ uint64_t feat_missing = get_required_bits() & ~(uint64_t)reply.features;
if (feat_missing) {
dout(1) << "missing required features " << std::hex << feat_missing << std::dec << dendl;
goto fail_locked;
}
-int SimpleMessenger::Pipe::write_ack(__u64 seq)
+int SimpleMessenger::Pipe::write_ack(uint64_t seq)
{
dout(10) << "write_ack " << seq << dendl;
bool keepalive;
__u32 connect_seq, peer_global_seq;
- __u64 out_seq;
- __u64 in_seq, in_seq_acked;
+ uint64_t out_seq;
+ uint64_t in_seq, in_seq_acked;
int get_required_bits(); /* get bits this Messenger requires
* the peer to support */
Message *read_message();
int write_message(Message *m);
int do_sendmsg(int sd, struct msghdr *msg, int len, bool more=false);
- int write_ack(__u64 s);
+ int write_ack(uint64_t s);
int write_keepalive();
void fault(bool silent=false, bool reader=false);
class entity_name_t {
public:
__u8 _type;
- __s64 _num;
+ int64_t _num;
public:
static const int TYPE_MON = CEPH_ENTITY_TYPE_MON;
// cons
entity_name_t() : _type(0), _num(0) { }
- entity_name_t(int t, __s64 n) : _type(t), _num(n) { }
+ entity_name_t(int t, int64_t n) : _type(t), _num(n) { }
entity_name_t(const ceph_entity_name &n) :
_type(n.type), _num(n.num) { }
static entity_name_t OSD(int i=NEW) { return entity_name_t(TYPE_OSD, i); }
static entity_name_t CLIENT(int i=NEW) { return entity_name_t(TYPE_CLIENT, i); }
- __s64 num() const { return _num; }
+ int64_t num() const { return _num; }
int type() const { return _type; }
const char *type_str() const {
return ceph_entity_type_name(type());
block_size = st.st_blksize;
if (create && max_size < (g_conf.osd_journal_size << 20)) {
- __u64 newsize = g_conf.osd_journal_size << 20;
+ uint64_t newsize = g_conf.osd_journal_size << 20;
dout(10) << "_open extending to " << newsize << " bytes" << dendl;
r = ::ftruncate(fd, newsize);
if (r == 0)
return 0;
}
-int FileJournal::open(__u64 next_seq)
+int FileJournal::open(uint64_t next_seq)
{
dout(2) << "open " << fn << " next_seq " << next_seq << dendl;
// find next entry
read_pos = header.start;
- __u64 seq = 0;
+ uint64_t seq = 0;
while (1) {
bufferlist bl;
off64_t old_pos = read_pos;
-int FileJournal::check_for_full(__u64 seq, off64_t pos, off64_t size)
+int FileJournal::check_for_full(uint64_t seq, off64_t pos, off64_t size)
{
// already full?
if (full_commit_seq || full_restart_seq)
return -ENOSPC;
}
-int FileJournal::prepare_multi_write(bufferlist& bl, __u64& orig_ops, __u64& orig_bytes)
+int FileJournal::prepare_multi_write(bufferlist& bl, uint64_t& orig_ops, uint64_t& orig_bytes)
{
// gather queued writes
off64_t queue_pos = write_pos;
return 0;
}
-int FileJournal::prepare_single_write(bufferlist& bl, off64_t& queue_pos, __u64& orig_ops, __u64& orig_bytes)
+int FileJournal::prepare_single_write(bufferlist& bl, off64_t& queue_pos, uint64_t& orig_ops, uint64_t& orig_bytes)
{
// grab next item
- __u64 seq = writeq.front().seq;
+ uint64_t seq = writeq.front().seq;
bufferlist &ebl = writeq.front().bl;
off64_t base_size = 2*sizeof(entry_header_t) + ebl.length();
off64_t size = ROUND_UP_TO(base_size, header.alignment);
// pop from writeq
writeq.pop_front();
- journalq.push_back(pair<__u64,off64_t>(seq, queue_pos));
+ journalq.push_back(pair<uint64_t,off64_t>(seq, queue_pos));
queue_pos += size;
if (queue_pos > header.max_size)
continue;
}
- __u64 orig_ops = 0;
- __u64 orig_bytes = 0;
+ uint64_t orig_ops = 0;
+ uint64_t orig_bytes = 0;
bufferlist bl;
int r = prepare_multi_write(bl, orig_ops, orig_bytes);
assert(r == 0);
do_write(bl);
- __u64 new_ops = throttle_ops.put(orig_ops);
- __u64 new_bytes = throttle_bytes.put(orig_bytes);
+ uint64_t new_ops = throttle_ops.put(orig_ops);
+ uint64_t new_bytes = throttle_bytes.put(orig_bytes);
dout(10) << "write_thread throttle finished " << orig_ops << " ops and "
<< orig_bytes << " bytes, now "
<< new_ops << " ops and " << new_bytes << " bytes"
}
-void FileJournal::submit_entry(__u64 seq, bufferlist& e, Context *oncommit)
+void FileJournal::submit_entry(uint64_t seq, bufferlist& e, Context *oncommit)
{
Mutex::Locker locker(write_lock); // ** lock **
}
-void FileJournal::committed_thru(__u64 seq)
+void FileJournal::committed_thru(uint64_t seq)
{
Mutex::Locker locker(write_lock);
}
}
-bool FileJournal::read_entry(bufferlist& bl, __u64& seq)
+bool FileJournal::read_entry(bufferlist& bl, uint64_t& seq)
{
if (!read_pos) {
dout(2) << "read_entry -- not readable" << dendl;
// ok!
seq = h->seq;
- journalq.push_back(pair<__u64,off64_t>(h->seq, read_pos));
+ journalq.push_back(pair<uint64_t,off64_t>(h->seq, read_pos));
read_pos = pos;
assert(read_pos % header.alignment == 0);
struct header_t {
__u32 version;
__u32 flags;
- __u64 fsid;
+ uint64_t fsid;
__u32 block_size;
__u32 alignment;
- __s64 max_size; // max size of journal ring buffer
- __s64 start; // offset of first entry
+ int64_t max_size; // max size of journal ring buffer
+ int64_t start; // offset of first entry
header_t() : version(1), flags(0), fsid(0), block_size(0), alignment(0), max_size(0), start(0) {}
off64_t write_pos; // byte where the next entry to be written will go
off64_t read_pos; //
- __u64 last_committed_seq;
+ uint64_t last_committed_seq;
- __u64 full_commit_seq; // don't write, wait for this seq to commit
- __u64 full_restart_seq; // start writing again with this seq
+ uint64_t full_commit_seq; // don't write, wait for this seq to commit
+ uint64_t full_restart_seq; // start writing again with this seq
int fd;
// in journal
- deque<pair<__u64, off64_t> > journalq; // track seq offsets, so we can trim later.
+ deque<pair<uint64_t, off64_t> > journalq; // track seq offsets, so we can trim later.
// currently being journaled and awaiting callback.
// or, awaiting callback bc journal was full.
- deque<__u64> writing_seq;
+ deque<uint64_t> writing_seq;
deque<Context*> writing_fin;
// waiting to be journaled
struct write_item {
- __u64 seq;
+ uint64_t seq;
bufferlist bl;
Context *fin;
- write_item(__u64 s, bufferlist& b, Context *f) : seq(s), fin(f) { bl.claim(b); }
+ write_item(uint64_t s, bufferlist& b, Context *f) : seq(s), fin(f) { bl.claim(b); }
};
deque<write_item> writeq;
void stop_writer();
void write_thread_entry();
- int check_for_full(__u64 seq, off64_t pos, off64_t size);
- int prepare_multi_write(bufferlist& bl, __u64& orig_ops, __u64& orig_bytee);
- int prepare_single_write(bufferlist& bl, off64_t& queue_pos, __u64& orig_ops, __u64& orig_bytes);
+ int check_for_full(uint64_t seq, off64_t pos, off64_t size);
+ int prepare_multi_write(bufferlist& bl, uint64_t& orig_ops, uint64_t& orig_bytee);
+ int prepare_single_write(bufferlist& bl, off64_t& queue_pos, uint64_t& orig_ops, uint64_t& orig_bytes);
void do_write(bufferlist& bl);
void write_bl(off64_t& pos, bufferlist& bl);
}
public:
- FileJournal(__u64 fsid, Finisher *fin, Cond *sync_cond, const char *f, bool dio=false) :
+ FileJournal(uint64_t fsid, Finisher *fin, Cond *sync_cond, const char *f, bool dio=false) :
Journal(fsid, fin, sync_cond), fn(f),
zero_buf(NULL),
max_size(0), block_size(0),
}
int create();
- int open(__u64 last_seq);
+ int open(uint64_t last_seq);
void close();
void flush();
void make_writeable();
// writes
- void submit_entry(__u64 seq, bufferlist& bl, Context *oncommit); // submit an item
- void committed_thru(__u64 seq);
+ void submit_entry(uint64_t seq, bufferlist& bl, Context *oncommit); // submit an item
+ void committed_thru(uint64_t seq);
bool is_full();
void set_wait_on_full(bool b) { wait_on_full = b; }
// reads
- bool read_entry(bufferlist& bl, __u64& seq);
+ bool read_entry(bufferlist& bl, uint64_t& seq);
};
#endif
} else if (!btrfs) {
dout(0) << "mount WARNING: not btrfs, store may be in inconsistent state" << dendl;
} else {
- __u64 cp = snaps.back();
+ uint64_t cp = snaps.back();
btrfs_ioctl_vol_args snapargs;
// drop current
op_fd = ::open(current_op_seq_fn, O_CREAT|O_RDWR, 0644);
assert(op_fd >= 0);
- __u64 initial_op_seq = 0;
+ uint64_t initial_op_seq = 0;
{
char s[40];
int l = ::read(op_fd, s, sizeof(s));
/// -----------------------------
-void FileStore::queue_op(Sequencer *posr, __u64 op_seq, list<Transaction*>& tls, Context *onreadable, Context *onreadable_sync)
+void FileStore::queue_op(Sequencer *posr, uint64_t op_seq, list<Transaction*>& tls, Context *onreadable, Context *onreadable_sync)
{
- __u64 bytes = 0, ops = 0;
+ uint64_t bytes = 0, ops = 0;
for (list<Transaction*>::iterator p = tls.begin();
p != tls.end();
p++) {
struct C_JournaledAhead : public Context {
FileStore *fs;
ObjectStore::Sequencer *osr;
- __u64 op;
+ uint64_t op;
list<ObjectStore::Transaction*> tls;
Context *onreadable, *onreadable_sync;
Context *ondisk;
- C_JournaledAhead(FileStore *f, ObjectStore::Sequencer *os, __u64 o, list<ObjectStore::Transaction*>& t,
+ C_JournaledAhead(FileStore *f, ObjectStore::Sequencer *os, uint64_t o, list<ObjectStore::Transaction*>& t,
Context *onr, Context *ond, Context *onrsync) :
fs(f), osr(os), op(o), tls(t), onreadable(onr), onreadable_sync(onrsync), ondisk(ond) { }
void finish(int r) {
journal->throttle();
- __u64 op = op_journal_start(0);
+ uint64_t op = op_journal_start(0);
dout(10) << "queue_transactions (parallel) " << op << " " << tls << dendl;
journal_transactions(tls, op, ondisk);
return 0;
}
else if (g_conf.filestore_journal_writeahead) {
- __u64 op = op_journal_start(0);
+ uint64_t op = op_journal_start(0);
dout(10) << "queue_transactions (writeahead) " << op << " " << tls << dendl;
journal_transactions(tls, op,
new C_JournaledAhead(this, osr, op, tls, onreadable, ondisk, onreadable_sync));
}
}
- __u64 op_seq = op_apply_start(0);
+ uint64_t op_seq = op_apply_start(0);
dout(10) << "queue_transactions (trailing journal) " << op_seq << " " << tls << dendl;
int r = do_transactions(tls, op_seq);
op_apply_finish();
return r;
}
-void FileStore::_journaled_ahead(Sequencer *osr, __u64 op,
+void FileStore::_journaled_ahead(Sequencer *osr, uint64_t op,
list<Transaction*> &tls,
Context *onreadable, Context *ondisk,
Context *onreadable_sync)
}
}
-int FileStore::do_transactions(list<Transaction*> &tls, __u64 op_seq)
+int FileStore::do_transactions(list<Transaction*> &tls, uint64_t op_seq)
{
int r = 0;
- __u64 bytes = 0, ops = 0;
+ uint64_t bytes = 0, ops = 0;
for (list<Transaction*>::iterator p = tls.begin();
p != tls.end();
p++) {
my_lock.Unlock();
dout(10) << "apply done r = " << r << dendl;
} else {
- __u64 op_seq = op_apply_start(0);
+ uint64_t op_seq = op_apply_start(0);
r = do_transactions(tls, op_seq);
op_apply_finish();
// btrfs transaction start/end interface
-int FileStore::_transaction_start(__u64 bytes, __u64 ops)
+int FileStore::_transaction_start(uint64_t bytes, uint64_t ops)
{
#ifdef DARWIN
return 0;
{
coll_t cid = t.get_cid();
sobject_t oid = t.get_oid();
- __u64 off = t.get_length();
- __u64 len = t.get_length();
+ uint64_t off = t.get_length();
+ uint64_t len = t.get_length();
bufferlist bl;
t.get_bl(bl);
_write(cid, oid, off, len, bl);
{
coll_t cid = t.get_cid();
sobject_t oid = t.get_oid();
- __u64 off = t.get_length();
- __u64 len = t.get_length();
+ uint64_t off = t.get_length();
+ uint64_t len = t.get_length();
_zero(cid, oid, off, len);
}
break;
{
coll_t cid = t.get_cid();
sobject_t oid = t.get_oid();
- __u64 off = t.get_length();
- __u64 len = t.get_length();
+ uint64_t off = t.get_length();
+ uint64_t len = t.get_length();
trim_from_cache(cid, oid, off, len);
}
break;
{
coll_t cid = t.get_cid();
sobject_t oid = t.get_oid();
- __u64 off = t.get_length();
+ uint64_t off = t.get_length();
_truncate(cid, oid, off);
}
break;
coll_t cid = t.get_cid();
sobject_t oid = t.get_oid();
sobject_t noid = t.get_oid();
- __u64 off = t.get_length();
- __u64 len = t.get_length();
+ uint64_t off = t.get_length();
+ uint64_t len = t.get_length();
_clone_range(cid, oid, noid, off, len);
}
break;
}
int FileStore::read(coll_t cid, const sobject_t& oid,
- __u64 offset, size_t len,
+ uint64_t offset, size_t len,
bufferlist& bl) {
char fn[PATH_MAX];
get_coname(cid, oid, fn, sizeof(fn));
dout(10) << "read couldn't open " << fn << " errno " << errno << " " << strerror_r(errno, buf, sizeof(buf)) << dendl;
r = -errno;
} else {
- __u64 actual = ::lseek64(fd, offset, SEEK_SET);
+ uint64_t actual = ::lseek64(fd, offset, SEEK_SET);
size_t got = 0;
if (len == 0) {
return r;
}
-int FileStore::_truncate(coll_t cid, const sobject_t& oid, __u64 size)
+int FileStore::_truncate(coll_t cid, const sobject_t& oid, uint64_t size)
{
char fn[PATH_MAX];
get_coname(cid, oid, fn, sizeof(fn));
}
int FileStore::_write(coll_t cid, const sobject_t& oid,
- __u64 offset, size_t len,
+ uint64_t offset, size_t len,
const bufferlist& bl)
{
char fn[PATH_MAX];
} else {
// seek
- __u64 actual = ::lseek64(fd, offset, SEEK_SET);
+ uint64_t actual = ::lseek64(fd, offset, SEEK_SET);
int did = 0;
assert(actual == offset);
return r;
}
-int FileStore::_zero(coll_t cid, const sobject_t& oid, __u64 offset, size_t len)
+int FileStore::_zero(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len)
{
// write zeros.. yuck!
bufferptr bp(len);
return 0;
}
-int FileStore::_do_clone_range(int from, int to, __u64 off, __u64 len)
+int FileStore::_do_clone_range(int from, int to, uint64_t off, uint64_t len)
{
dout(20) << "_do_clone_range " << off << "~" << len << dendl;
int r = 0;
return r;
}
-int FileStore::_clone_range(coll_t cid, const sobject_t& oldoid, const sobject_t& newoid, __u64 off, __u64 len)
+int FileStore::_clone_range(coll_t cid, const sobject_t& oldoid, const sobject_t& newoid, uint64_t off, uint64_t len)
{
char ofn[PATH_MAX], nfn[PATH_MAX];
get_coname(cid, oldoid, ofn, sizeof(ofn));
}
-bool FileStore::queue_flusher(int fd, __u64 off, __u64 len)
+bool FileStore::queue_flusher(int fd, uint64_t off, uint64_t len)
{
bool queued;
lock.Lock();
while (true) {
if (!flusher_queue.empty()) {
#ifdef HAVE_SYNC_FILE_RANGE
- list<__u64> q;
+ list<uint64_t> q;
q.swap(flusher_queue);
int num = flusher_queue_len; // see how many we're taking, here
lock.Unlock();
while (!q.empty()) {
- __u64 ep = q.front();
+ uint64_t ep = q.front();
q.pop_front();
int fd = q.front();
q.pop_front();
- __u64 off = q.front();
+ uint64_t off = q.front();
q.pop_front();
- __u64 len = q.front();
+ uint64_t len = q.front();
q.pop_front();
if (!stop && ep == sync_epoch) {
dout(10) << "flusher_entry flushing+closing " << fd << " ep " << ep << dendl;
if (commit_start()) {
utime_t start = g_clock.now();
- __u64 cp = op_seq;
+ uint64_t cp = op_seq;
// make flusher stop flushing previously queued stuff
sync_epoch++;
string basedir, journalpath;
char current_fn[PATH_MAX];
char current_op_seq_fn[PATH_MAX];
- __u64 fsid;
+ uint64_t fsid;
bool btrfs;
bool btrfs_trans_start_end;
int fsid_fd, op_fd;
int basedir_fd, current_fd;
- deque<__u64> snaps;
+ deque<uint64_t> snaps;
// fake attrs?
FakeAttrs attrs;
// sync thread
Mutex lock;
Cond sync_cond;
- __u64 sync_epoch;
+ uint64_t sync_epoch;
bool stop;
void sync_entry();
struct SyncThread : public Thread {
// -- op workqueue --
struct Op {
- __u64 op;
+ uint64_t op;
list<Transaction*> tls;
Context *onreadable, *onreadable_sync;
- __u64 ops, bytes;
+ uint64_t ops, bytes;
};
struct OpSequencer {
Sequencer *parent;
};
Sequencer default_osr;
deque<OpSequencer*> op_queue;
- __u64 op_queue_len, op_queue_bytes;
+ uint64_t op_queue_len, op_queue_bytes;
Cond op_throttle_cond;
Finisher op_finisher;
- __u64 next_finish;
- map<__u64, pair<Context*,Context*> > finish_queue;
+ uint64_t next_finish;
+ map<uint64_t, pair<Context*,Context*> > finish_queue;
ThreadPool op_tp;
struct OpWQ : public ThreadPool::WorkQueue<OpSequencer> {
void _do_op(OpSequencer *o);
void _finish_op(OpSequencer *o);
- void queue_op(Sequencer *osr, __u64 op, list<Transaction*>& tls, Context *onreadable, Context *onreadable_sync);
- void _journaled_ahead(Sequencer *osr, __u64 op, list<Transaction*> &tls,
+ void queue_op(Sequencer *osr, uint64_t op, list<Transaction*>& tls, Context *onreadable, Context *onreadable_sync);
+ void _journaled_ahead(Sequencer *osr, uint64_t op, list<Transaction*> &tls,
Context *onreadable, Context *ondisk, Context *onreadable_sync);
friend class C_JournaledAhead;
// flusher thread
Cond flusher_cond;
- list<__u64> flusher_queue;
+ list<uint64_t> flusher_queue;
int flusher_queue_len;
void flusher_entry();
struct FlusherThread : public Thread {
return 0;
}
} flusher_thread;
- bool queue_flusher(int fd, __u64 off, __u64 len);
+ bool queue_flusher(int fd, uint64_t off, uint64_t len);
int open_journal();
int statfs(struct statfs *buf);
- int do_transactions(list<Transaction*> &tls, __u64 op_seq);
+ int do_transactions(list<Transaction*> &tls, uint64_t op_seq);
unsigned apply_transaction(Transaction& t, Context *ondisk=0);
unsigned apply_transactions(list<Transaction*>& tls, Context *ondisk=0);
- int _transaction_start(__u64 bytes, __u64 ops);
+ int _transaction_start(uint64_t bytes, uint64_t ops);
void _transaction_finish(int id);
unsigned _do_transaction(Transaction& t);
}
bool exists(coll_t cid, const sobject_t& oid);
int stat(coll_t cid, const sobject_t& oid, struct stat *st);
- int read(coll_t cid, const sobject_t& oid, __u64 offset, size_t len, bufferlist& bl);
+ int read(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len, bufferlist& bl);
int _touch(coll_t cid, const sobject_t& oid);
- int _write(coll_t cid, const sobject_t& oid, __u64 offset, size_t len, const bufferlist& bl);
- int _zero(coll_t cid, const sobject_t& oid, __u64 offset, size_t len);
- int _truncate(coll_t cid, const sobject_t& oid, __u64 size);
+ int _write(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len, const bufferlist& bl);
+ int _zero(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len);
+ int _truncate(coll_t cid, const sobject_t& oid, uint64_t size);
int _clone(coll_t cid, const sobject_t& oldoid, const sobject_t& newoid);
- int _clone_range(coll_t cid, const sobject_t& oldoid, const sobject_t& newoid, __u64 off, __u64 len);
- int _do_clone_range(int from, int to, __u64 off, __u64 len);
+ int _clone_range(coll_t cid, const sobject_t& oldoid, const sobject_t& newoid, uint64_t off, uint64_t len);
+ int _do_clone_range(int from, int to, uint64_t off, uint64_t len);
int _remove(coll_t cid, const sobject_t& oid);
void _start_sync();
int _collection_add(coll_t c, coll_t ocid, const sobject_t& o);
int _collection_remove(coll_t c, const sobject_t& o);
- void trim_from_cache(coll_t cid, const sobject_t& oid, __u64 offset, size_t len) {}
- int is_cached(coll_t cid, const sobject_t& oid, __u64 offset, size_t len) { return -1; }
+ void trim_from_cache(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len) {}
+ int is_cached(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len) { return -1; }
};
#endif
class Journal {
protected:
- __u64 fsid;
+ uint64_t fsid;
Finisher *finisher;
Cond *do_sync_cond;
bool wait_on_full;
public:
- Journal(__u64 f, Finisher *fin, Cond *c=0) : fsid(f), finisher(fin),
+ Journal(uint64_t f, Finisher *fin, Cond *c=0) : fsid(f), finisher(fin),
do_sync_cond(c),
wait_on_full(false) { }
virtual ~Journal() { }
virtual int create() = 0;
- virtual int open(__u64 last_seq) = 0;
+ virtual int open(uint64_t last_seq) = 0;
virtual void close() = 0;
virtual void flush() = 0;
// writes
virtual bool is_writeable() = 0;
virtual void make_writeable() = 0;
- virtual void submit_entry(__u64 seq, bufferlist& e, Context *oncommit) = 0;
- virtual void committed_thru(__u64 seq) = 0;
- virtual bool read_entry(bufferlist& bl, __u64 &seq) = 0;
+ virtual void submit_entry(uint64_t seq, bufferlist& e, Context *oncommit) = 0;
+ virtual void committed_thru(uint64_t seq) = 0;
+ virtual bool read_entry(bufferlist& bl, uint64_t &seq) = 0;
// reads/recovery
}
}
-int JournalingObjectStore::journal_replay(__u64 fs_op_seq)
+int JournalingObjectStore::journal_replay(uint64_t fs_op_seq)
{
dout(10) << "journal_replay fs op_seq " << fs_op_seq << dendl;
op_seq = fs_op_seq;
int count = 0;
while (1) {
bufferlist bl;
- __u64 seq = op_seq + 1;
+ uint64_t seq = op_seq + 1;
if (!journal->read_entry(bl, seq)) {
dout(3) << "journal_replay: end of journal, done." << dendl;
break;
// ------------------------------------
-__u64 JournalingObjectStore::op_apply_start(__u64 op)
+uint64_t JournalingObjectStore::op_apply_start(uint64_t op)
{
lock.Lock();
while (blocked) {
lock.Unlock();
}
-__u64 JournalingObjectStore::op_journal_start(__u64 op)
+uint64_t JournalingObjectStore::op_journal_start(uint64_t op)
{
journal_lock.Lock();
if (!op) {
}
}
-void JournalingObjectStore::journal_transaction(ObjectStore::Transaction& t, __u64 op,
+void JournalingObjectStore::journal_transaction(ObjectStore::Transaction& t, uint64_t op,
Context *onjournal)
{
Mutex::Locker l(lock);
commit_waiters[op].push_back(onjournal);
}
-void JournalingObjectStore::journal_transactions(list<ObjectStore::Transaction*>& tls, __u64 op,
+void JournalingObjectStore::journal_transactions(list<ObjectStore::Transaction*>& tls, uint64_t op,
Context *onjournal)
{
Mutex::Locker l(lock);
class JournalingObjectStore : public ObjectStore {
protected:
- __u64 op_seq, applied_seq;
- __u64 committing_seq, committed_seq;
+ uint64_t op_seq, applied_seq;
+ uint64_t committing_seq, committed_seq;
map<version_t, vector<Context*> > commit_waiters;
int open_ops;
protected:
void journal_start();
void journal_stop();
- int journal_replay(__u64 fs_op_seq);
+ int journal_replay(uint64_t fs_op_seq);
// --
- __u64 op_apply_start(__u64 op);
+ uint64_t op_apply_start(uint64_t op);
void op_apply_finish();
- __u64 op_journal_start(__u64 op);
+ uint64_t op_journal_start(uint64_t op);
void op_journal_finish();
- void journal_transaction(ObjectStore::Transaction& t, __u64 op, Context *onjournal);
- void journal_transactions(list<ObjectStore::Transaction*>& tls, __u64 op, Context *onjournal);
+ void journal_transaction(ObjectStore::Transaction& t, uint64_t op, Context *onjournal);
+ void journal_transactions(list<ObjectStore::Transaction*>& tls, uint64_t op, Context *onjournal);
bool commit_start();
void commit_started(); // allow new ops (underlying fs should now be committing all prior ops)
# define MIN(a,b) ((a) < (b) ? (a):(b))
#endif
-typedef __u64 collection_list_handle_t;
+typedef uint64_t collection_list_handle_t;
/*
* low-level interface to the local OSD file system
static const int OP_RMATTRS = 28; // cid, oid
private:
- __u64 ops, bytes;
+ uint64_t ops, bytes;
bufferlist tbl;
bufferlist::iterator p;
unsigned opp, blp, oidp, cidp, lengthp, attrnamep, attrsetp;
public:
- __u64 get_num_bytes() {
+ uint64_t get_num_bytes() {
if (old) {
- __u64 s = 16384 +
+ uint64_t s = 16384 +
(opvec.size() + oids.size() + cids.size() + lengths.size()) * 4096;
for (vector<bufferlist>::iterator p = bls.begin(); p != bls.end(); p++)
s += bls.size() + 4096;
::decode(c, p);
return c;
}
- __u64 get_length() {
+ uint64_t get_length() {
if (old)
return lengths[lengthp++];
if (p.get_off() == 0)
p = tbl.begin();
- __u64 len;
+ uint64_t len;
::decode(len, p);
return len;
}
::encode(oid, tbl);
ops++;
}
- void write(coll_t cid, const sobject_t& oid, __u64 off, __u64 len, const bufferlist& data) {
+ void write(coll_t cid, const sobject_t& oid, uint64_t off, uint64_t len, const bufferlist& data) {
__u32 op = OP_WRITE;
::encode(op, tbl);
::encode(cid, tbl);
::encode(data, tbl);
ops++;
}
- void zero(coll_t cid, const sobject_t& oid, __u64 off, __u64 len) {
+ void zero(coll_t cid, const sobject_t& oid, uint64_t off, uint64_t len) {
__u32 op = OP_ZERO;
::encode(op, tbl);
::encode(cid, tbl);
::encode(len, tbl);
ops++;
}
- void trim_from_cache(coll_t cid, const sobject_t& oid, __u64 off, __u64 len) {
+ void trim_from_cache(coll_t cid, const sobject_t& oid, uint64_t off, uint64_t len) {
__u32 op = OP_TRIMCACHE;
::encode(op, tbl);
::encode(cid, tbl);
::encode(len, tbl);
ops++;
}
- void truncate(coll_t cid, const sobject_t& oid, __u64 off) {
+ void truncate(coll_t cid, const sobject_t& oid, uint64_t off) {
__u32 op = OP_TRUNCATE;
::encode(op, tbl);
::encode(cid, tbl);
::encode(noid, tbl);
ops++;
}
- void clone_range(coll_t cid, const sobject_t& oid, sobject_t noid, __u64 off, __u64 len) {
+ void clone_range(coll_t cid, const sobject_t& oid, sobject_t noid, uint64_t off, uint64_t len) {
__u32 op = OP_CLONERANGE;
::encode(op, tbl);
::encode(cid, tbl);
// objects
virtual bool exists(coll_t cid, const sobject_t& oid) = 0; // useful?
virtual int stat(coll_t cid, const sobject_t& oid, struct stat *st) = 0; // struct stat?
- virtual int read(coll_t cid, const sobject_t& oid, __u64 offset, size_t len, bufferlist& bl) = 0;
+ virtual int read(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len, bufferlist& bl) = 0;
/*
virtual int _remove(coll_t cid, sobject_t oid) = 0;
- virtual int _truncate(coll_t cid, sobject_t oid, __u64 size) = 0;
- virtual int _write(coll_t cid, sobject_t oid, __u64 offset, size_t len, const bufferlist& bl) = 0;
- virtual int _zero(coll_t cid, sobject_t oid, __u64 offset, size_t len) {
+ virtual int _truncate(coll_t cid, sobject_t oid, uint64_t size) = 0;
+ virtual int _write(coll_t cid, sobject_t oid, uint64_t offset, size_t len, const bufferlist& bl) = 0;
+ virtual int _zero(coll_t cid, sobject_t oid, uint64_t offset, size_t len) {
// write zeros.. yuck!
bufferptr bp(len);
bufferlist bl;
}
*/
- virtual void trim_from_cache(coll_t cid, const sobject_t& oid, __u64 offset, size_t len) = 0; //{ }
- virtual int is_cached(coll_t cid, const sobject_t& oid, __u64 offset, size_t len) = 0; //{ return -1; }
+ virtual void trim_from_cache(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len) = 0; //{ }
+ virtual int is_cached(coll_t cid, const sobject_t& oid, uint64_t offset, size_t len) = 0; //{ return -1; }
virtual int getattr(coll_t cid, const sobject_t& oid, const char *name, void *value, size_t size) = 0;
virtual int getattr(coll_t cid, const sobject_t& oid, const char *name, bufferptr& value) = 0;
/* this should be 4k */
struct btrfs_ioctl_vol_args {
- __s64 fd;
+ int64_t fd;
char name[BTRFS_PATH_NAME_MAX + 1];
};
struct btrfs_ioctl_clone_range_args {
- __s64 src_fd;
- __u64 src_offset, src_length;
- __u64 dest_offset;
+ int64_t src_fd;
+ uint64_t src_offset, src_length;
+ uint64_t dest_offset;
};
#define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
AuthCapsInfo caps_info;
EntityName name;
uint64_t global_id;
- __u64 auid;
+ uint64_t auid;
isvalid = authorize_handler->verify_authorizer(monc->rotating_secrets,
authorizer_data, authorizer_reply, name, global_id, caps_info, &auid);
* on the pool, check if you're the pool owner and grant full.
* Otherwise, you get nothing.
*/
-int OSDCaps::get_pool_cap(int pool_id, __u64 uid)
+int OSDCaps::get_pool_cap(int pool_id, uint64_t uid)
{
if (allow_all)
return OSD_POOL_CAP_ALL;
rwx_t default_action;
bool allow_all;
int peer_type;
- __u64 auid;
+ uint64_t auid;
bool get_next_token(string s, size_t& pos, string& token);
bool is_rwx(string& token, rwx_t& cap_val);
OSDCaps() : default_action(0), allow_all(false),
auid(CEPH_AUTH_UID_DEFAULT) {}
bool parse(bufferlist::iterator& iter);
- int get_pool_cap(int pool_id, __u64 uid = CEPH_AUTH_UID_DEFAULT);
+ int get_pool_cap(int pool_id, uint64_t uid = CEPH_AUTH_UID_DEFAULT);
bool is_mon() { return CEPH_ENTITY_TYPE_MON == peer_type; }
bool is_osd() { return CEPH_ENTITY_TYPE_OSD == peer_type; }
bool is_mds() { return CEPH_ENTITY_TYPE_MDS == peer_type; }
void set_allow_all(bool allow) { allow_all = allow; }
void set_peer_type (int pt) { peer_type = pt; }
- void set_auid(__u64 uid) { auid = uid; }
+ void set_auid(uint64_t uid) { auid = uid; }
};
static inline ostream& operator<<(ostream& out, const OSDCaps& c) {
for (list<Log::Entry>::iterator p = log.log.begin();
p != log.log.end();
p++) {
- __u64 startoff = bl.length();
+ uint64_t startoff = bl.length();
::encode(*p, bl);
- __u64 endoff = bl.length();
+ uint64_t endoff = bl.length();
if (startoff / 4096 != endoff / 4096) {
// we reached a new block. *p was the last entry with bytes in previous block
ondisklog.block_map[startoff] = p->version;
{
dout(15) << "trim_ondisk_log_to v " << v << dendl;
- map<__u64,eversion_t>::iterator p = ondisklog.block_map.begin();
+ map<uint64_t,eversion_t>::iterator p = ondisklog.block_map.begin();
while (p != ondisklog.block_map.end()) {
//dout(15) << " " << p->first << " -> " << p->second << dendl;
p++;
return; // can't trim anything!
// we can trim!
- __u64 trim = p->first;
+ uint64_t trim = p->first;
dout(10) << " " << ondisklog.tail << "~" << ondisklog.length()
<< " -> " << trim << "~" << (ondisklog.head-trim)
<< dendl;
eversion_t last;
bool reorder = false;
while (!p.end()) {
- __u64 pos = ondisklog.tail + p.get_off();
+ uint64_t pos = ondisklog.tail + p.get_off();
::decode(e, p);
dout(20) << "read_log " << pos << " " << e << dendl;
osd->get_logclient()->log(LOG_ERROR, ss);
}
- __u64 endpos = ondisklog.tail + p.get_off();
+ uint64_t endpos = ondisklog.tail + p.get_off();
if (endpos / 4096 != pos / 4096)
ondisklog.block_map[pos] = e.version; // last event in prior block
log.log.push_back(e);
class OndiskLog {
public:
// ok
- __u64 tail; // first byte of log.
- __u64 head; // byte following end of log.
- map<__u64,eversion_t> block_map; // offset->version of _last_ entry with _any_ bytes in each block
+ uint64_t tail; // first byte of log.
+ uint64_t head; // byte following end of log.
+ map<uint64_t,eversion_t> block_map; // offset->version of _last_ entry with _any_ bytes in each block
OndiskLog() : tail(0), head(0) {}
- __u64 length() { return head - tail; }
+ uint64_t length() { return head - tail; }
bool trim_to(eversion_t v, ObjectStore::Transaction& t);
void encode(bufferlist& bl) const {
list<object_t> entries;
void encode(bufferlist& bl) const {
- ::encode((__u64)handle, bl);
+ ::encode((uint64_t)handle, bl);
::encode(entries, bl);
}
void decode(bufferlist::iterator& bl) {
- __u64 tmp;
+ uint64_t tmp;
::decode(tmp, bl);
handle = (collection_list_handle_t)tmp;
::decode(entries, bl);
dout(10) << " pgls pg=" << op->get_pg() << dendl;
// read into a buffer
PGLSResponse response;
- response.handle = (collection_list_handle_t)(__u64)(p->op.pgls.cookie);
+ response.handle = (collection_list_handle_t)(uint64_t)(p->op.pgls.cookie);
vector<sobject_t> sentries;
result = osd->store->collection_list_partial(coll_t::build_pg_coll(info.pgid), snapid,
sentries, p->op.pgls.count,
// note some basic context for op replication that prepare_transaction may clobber
eversion_t old_last_update = ctx->at_version;
bool old_exists = obc->obs.exists;
- __u64 old_size = obc->obs.oi.size;
+ uint64_t old_size = obc->obs.oi.size;
eversion_t old_version = obc->obs.oi.version;
// we are acker.
if (p != snapset.clones.begin()) {
// not the oldest... merge overlap into next older clone
vector<snapid_t>::iterator n = p - 1;
- interval_set<__u64> keep;
+ interval_set<uint64_t> keep;
keep.union_of(snapset.clone_overlap[*n], snapset.clone_overlap[*p]);
add_interval_usage(keep, info.stats); // not deallocated
snapset.clone_overlap[*n].intersection_of(snapset.clone_overlap[*p]);
memset(&st, 0, sizeof(st));
result = osd->store->stat(coll_t::build_pg_coll(info.pgid), soid, &st);
if (result >= 0) {
- __u64 size = st.st_size;
+ uint64_t size = st.st_size;
::encode(size, odata);
::encode(oi.mtime, odata);
}
}
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
- interval_set<__u64> ch;
+ interval_set<uint64_t> ch;
if (op.extent.length)
ch.insert(op.extent.offset, op.extent.length);
ch.intersection_of(ssc->snapset.clone_overlap[newest]);
add_interval_usage(ch, info.stats);
}
if (op.extent.length && (op.extent.offset + op.extent.length > oi.size)) {
- __u64 new_size = op.extent.offset + op.extent.length;
+ uint64_t new_size = op.extent.offset + op.extent.length;
info.stats.num_bytes += new_size - oi.size;
info.stats.num_kb += SHIFT_ROUND_UP(new_size, 10) - SHIFT_ROUND_UP(oi.size, 10);
oi.size = new_size;
t.zero(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
- interval_set<__u64> ch;
+ interval_set<uint64_t> ch;
ch.insert(op.extent.offset, op.extent.length);
ch.intersection_of(ssc->snapset.clone_overlap[newest]);
ssc->snapset.clone_overlap[newest].subtract(ch);
t.truncate(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
- interval_set<__u64> trim;
+ interval_set<uint64_t> trim;
if (oi.size > op.extent.offset) {
trim.insert(op.extent.offset, oi.size-op.extent.offset);
trim.intersection_of(ssc->snapset.clone_overlap[newest]);
add_interval_usage(trim, info.stats);
}
- interval_set<__u64> keep;
+ interval_set<uint64_t> keep;
if (op.extent.offset)
keep.insert(0, op.extent.offset);
ssc->snapset.clone_overlap[newest].intersection_of(keep);
}
-void ReplicatedPG::add_interval_usage(interval_set<__u64>& s, pg_stat_t& stats)
+void ReplicatedPG::add_interval_usage(interval_set<uint64_t>& s, pg_stat_t& stats)
{
- for (map<__u64,__u64>::iterator p = s.m.begin(); p != s.m.end(); p++) {
+ for (map<uint64_t,uint64_t>::iterator p = s.m.begin(); p != s.m.end(); p++) {
stats.num_bytes += p->second;
stats.num_kb += SHIFT_ROUND_UP(p->first+p->second, 10) - (p->first >> 10);
}
void ReplicatedPG::issue_repop(RepGather *repop, int dest, utime_t now,
- bool old_exists, __u64 old_size, eversion_t old_version)
+ bool old_exists, uint64_t old_size, eversion_t old_version)
{
const sobject_t& soid = repop->ctx->obs->oi.soid;
dout(7) << " issue_repop rep_tid " << repop->rep_tid
void ReplicatedPG::calc_head_subsets(SnapSet& snapset, const sobject_t& head,
Missing& missing,
- interval_set<__u64>& data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets)
+ interval_set<uint64_t>& data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets)
{
dout(10) << "calc_head_subsets " << head
<< " clone_overlap " << snapset.clone_overlap << dendl;
struct stat st;
osd->store->stat(coll_t::build_pg_coll(info.pgid), head, &st);
- interval_set<__u64> cloning;
- interval_set<__u64> prev;
+ interval_set<uint64_t> cloning;
+ interval_set<uint64_t> prev;
if (st.st_size)
prev.insert(0, st.st_size);
void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, const sobject_t& soid,
Missing& missing,
- interval_set<__u64>& data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets)
+ interval_set<uint64_t>& data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets)
{
dout(10) << "calc_clone_subsets " << soid
<< " clone_overlap " << snapset.clone_overlap << dendl;
- __u64 size = snapset.clone_size[soid.snap];
+ uint64_t size = snapset.clone_size[soid.snap];
unsigned i;
for (i=0; i < snapset.clones.size(); i++)
break;
// any overlap with next older clone?
- interval_set<__u64> cloning;
- interval_set<__u64> prev;
+ interval_set<uint64_t> cloning;
+ interval_set<uint64_t> prev;
if (size)
prev.insert(0, size);
for (int j=i-1; j>=0; j--) {
}
// overlap with next newest?
- interval_set<__u64> next;
+ interval_set<uint64_t> next;
if (size)
next.insert(0, size);
for (unsigned j=i+1; j<snapset.clones.size(); j++) {
if (fromosd < 0)
return false;
- map<sobject_t, interval_set<__u64> > clone_subsets;
- interval_set<__u64> data_subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ interval_set<uint64_t> data_subset;
// is this a snapped object? if so, consult the snapset.. we may not need the entire object!
if (soid.snap && soid.snap < CEPH_NOSNAP) {
int r = osd->store->stat(coll_t::build_pg_coll(info.pgid), soid, &st);
assert(r == 0);
- map<sobject_t, interval_set<__u64> > clone_subsets;
- interval_set<__u64> data_subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ interval_set<uint64_t> data_subset;
bufferlist bv;
r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, OI_ATTR, bv);
dout(10) << "push_to_replica osd" << peer << " has correct old " << head
<< " v" << oi.prior_version
<< ", pushing " << soid << " attrs as a clone op" << dendl;
- interval_set<__u64> data_subset;
- map<sobject_t, interval_set<__u64> > clone_subsets;
+ interval_set<uint64_t> data_subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
if (st.st_size)
clone_subsets[head].insert(0, st.st_size);
push(soid, peer, data_subset, clone_subsets);
*/
void ReplicatedPG::push(const sobject_t& soid, int peer)
{
- interval_set<__u64> subset;
- map<sobject_t, interval_set<__u64> > clone_subsets;
+ interval_set<uint64_t> subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
push(soid, peer, subset, clone_subsets);
}
void ReplicatedPG::push(const sobject_t& soid, int peer,
- interval_set<__u64> &data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets)
+ interval_set<uint64_t> &data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets)
{
// read data+attrs
bufferlist bl;
map<nstring,bufferptr> attrset;
- __u64 size;
+ uint64_t size;
if (data_subset.size() || clone_subsets.size()) {
struct stat st;
assert(r == 0);
size = st.st_size;
- for (map<__u64,__u64>::iterator p = data_subset.m.begin();
+ for (map<uint64_t,uint64_t>::iterator p = data_subset.m.begin();
p != data_subset.m.end();
p++) {
bufferlist bit;
<< " data len " << op->get_data().length()
<< dendl;
- interval_set<__u64> data_subset;
- map<sobject_t, interval_set<__u64> > clone_subsets;
+ interval_set<uint64_t> data_subset;
+ map<sobject_t, interval_set<uint64_t> > clone_subsets;
bufferlist data;
data.claim(op->get_data());
clone_subsets.clear(); // forget what pusher said; recalculate cloning.
- interval_set<__u64> data_needed;
+ interval_set<uint64_t> data_needed;
calc_clone_subsets(ssc->snapset, soid, missing, data_needed, clone_subsets);
put_snapset_context(ssc);
// did we get more data than we need?
if (!data_subset.subset_of(data_needed)) {
- interval_set<__u64> extra = data_subset;
+ interval_set<uint64_t> extra = data_subset;
extra.subtract(data_needed);
dout(10) << " we got some extra: " << extra << dendl;
bufferlist result;
int off = 0;
- for (map<__u64,__u64>::iterator p = data_subset.m.begin();
+ for (map<uint64_t,uint64_t>::iterator p = data_subset.m.begin();
p != data_subset.m.end();
p++) {
- interval_set<__u64> x;
+ interval_set<uint64_t> x;
x.insert(p->first, p->second);
x.intersection_of(data_needed);
dout(20) << " data_subset object extent " << p->first << "~" << p->second << " need " << x << dendl;
if (!x.empty()) {
- __u64 first = x.m.begin()->first;
- __u64 len = x.m.begin()->second;
+ uint64_t first = x.m.begin()->first;
+ uint64_t len = x.m.begin()->second;
bufferlist sub;
int boff = off + (first - p->first);
dout(20) << " keeping buffer extent " << boff << "~" << len << dendl;
ObjectStore::Transaction *t = new ObjectStore::Transaction;
t->remove(coll_t::build_pg_coll(info.pgid), soid); // in case old version exists
- __u64 boff = 0;
- for (map<sobject_t, interval_set<__u64> >::iterator p = clone_subsets.begin();
+ uint64_t boff = 0;
+ for (map<sobject_t, interval_set<uint64_t> >::iterator p = clone_subsets.begin();
p != clone_subsets.end();
p++)
- for (map<__u64,__u64>::iterator q = p->second.m.begin();
+ for (map<uint64_t,uint64_t>::iterator q = p->second.m.begin();
q != p->second.m.end();
q++) {
dout(15) << " clone_range " << p->first << " " << q->first << "~" << q->second << dendl;
t->clone_range(coll_t::build_pg_coll(info.pgid), p->first, soid, q->first, q->second);
}
- for (map<__u64,__u64>::iterator p = data_subset.m.begin();
+ for (map<uint64_t,uint64_t>::iterator p = data_subset.m.begin();
p != data_subset.m.end();
p++) {
bufferlist bit;
curclone = snapset.clones.size()-1;
// subtract off any clone overlap
- for (map<snapid_t,interval_set<__u64> >::iterator q = snapset.clone_overlap.begin();
+ for (map<snapid_t,interval_set<uint64_t> >::iterator q = snapset.clone_overlap.begin();
q != snapset.clone_overlap.end();
q++) {
- for (map<__u64,__u64>::iterator r = q->second.m.begin();
+ for (map<uint64_t,uint64_t>::iterator r = q->second.m.begin();
r != q->second.m.end();
r++) {
stat.num_bytes -= r->second;
void op_commit(RepGather *repop);
void eval_repop(RepGather*);
void issue_repop(RepGather *repop, int dest, utime_t now,
- bool old_exists, __u64 old_size, eversion_t old_version);
+ bool old_exists, uint64_t old_size, eversion_t old_version);
RepGather *new_repop(OpContext *ctx, ObjectContext *obc, bool noop, tid_t rep_tid);
void repop_ack(RepGather *repop,
int result, int ack_type,
void calc_head_subsets(SnapSet& snapset, const sobject_t& head,
Missing& missing,
- interval_set<__u64>& data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets);
+ interval_set<uint64_t>& data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets);
void calc_clone_subsets(SnapSet& snapset, const sobject_t& poid, Missing& missing,
- interval_set<__u64>& data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets);
+ interval_set<uint64_t>& data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets);
void push_to_replica(const sobject_t& oid, int dest);
void push(const sobject_t& oid, int dest);
- void push(const sobject_t& oid, int dest, interval_set<__u64>& data_subset,
- map<sobject_t, interval_set<__u64> >& clone_subsets);
+ void push(const sobject_t& oid, int dest, interval_set<uint64_t>& data_subset,
+ map<sobject_t, interval_set<uint64_t> >& clone_subsets);
bool pull(const sobject_t& oid);
object_info_t *poi);
void make_writeable(OpContext *ctx);
void log_op_stats(const sobject_t &soid, OpContext *ctx);
- void add_interval_usage(interval_set<__u64>& s, pg_stat_t& st);
+ void add_interval_usage(interval_set<uint64_t>& s, pg_stat_t& st);
int prepare_transaction(OpContext *ctx);
void log_op(vector<Log::Entry>& log, eversion_t trim_to, ObjectStore::Transaction& t);
eversion_t last_scrub;
utime_t last_scrub_stamp;
- __u64 num_bytes; // in bytes
- __u64 num_kb; // in KB
- __u64 num_objects;
- __u64 num_object_clones;
- __u64 num_object_copies; // num_objects * num_replicas
- __u64 num_objects_missing_on_primary;
- __u64 num_objects_degraded;
- __u64 log_size;
- __u64 ondisk_log_size; // >= active_log_size
-
- __u64 num_rd, num_rd_kb;
- __u64 num_wr, num_wr_kb;
+ uint64_t num_bytes; // in bytes
+ uint64_t num_kb; // in KB
+ uint64_t num_objects;
+ uint64_t num_object_clones;
+ uint64_t num_object_copies; // num_objects * num_replicas
+ uint64_t num_objects_missing_on_primary;
+ uint64_t num_objects_degraded;
+ uint64_t log_size;
+ uint64_t ondisk_log_size; // >= active_log_size
+
+ uint64_t num_rd, num_rd_kb;
+ uint64_t num_wr, num_wr_kb;
vector<int> up, acting;
* summation over an entire pool
*/
struct pool_stat_t {
- __u64 num_bytes; // in bytes
- __u64 num_kb; // in KB
- __u64 num_objects;
- __u64 num_object_clones;
- __u64 num_object_copies; // num_objects * num_replicas
- __u64 num_objects_missing_on_primary;
- __u64 num_objects_degraded;
- __u64 log_size;
- __u64 ondisk_log_size; // >= active_log_size
- __u64 num_rd, num_rd_kb;
- __u64 num_wr, num_wr_kb;
+ uint64_t num_bytes; // in bytes
+ uint64_t num_kb; // in KB
+ uint64_t num_objects;
+ uint64_t num_object_clones;
+ uint64_t num_object_copies; // num_objects * num_replicas
+ uint64_t num_objects_missing_on_primary;
+ uint64_t num_objects_degraded;
+ uint64_t log_size;
+ uint64_t ondisk_log_size; // >= active_log_size
+ uint64_t num_rd, num_rd_kb;
+ uint64_t num_wr, num_wr_kb;
pool_stat_t() : num_bytes(0), num_kb(0),
num_objects(0), num_object_clones(0), num_object_copies(0),
// -------
-WRITE_CLASS_ENCODER(interval_set<__u64>)
+WRITE_CLASS_ENCODER(interval_set<uint64_t>)
bool head_exists;
vector<snapid_t> snaps; // ascending
vector<snapid_t> clones; // ascending
- map<snapid_t, interval_set<__u64> > clone_overlap; // overlap w/ next newest
- map<snapid_t, __u64> clone_size;
+ map<snapid_t, interval_set<uint64_t> > clone_overlap; // overlap w/ next newest
+ map<snapid_t, uint64_t> clone_size;
SnapSet() : head_exists(false) {}
SnapSet(bufferlist& bl) {
eversion_t version, prior_version;
osd_reqid_t last_reqid;
- __u64 size;
+ uint64_t size;
utime_t mtime;
osd_reqid_t wrlock_by; // [head]
vector<snapid_t> snaps; // [clone]
- __u64 truncate_seq, truncate_size;
+ uint64_t truncate_seq, truncate_size;
void encode(bufferlist& bl) const {
const __u8 v = 1;
struct ScrubMap {
struct object {
sobject_t poid;
- __u64 size;
+ uint64_t size;
map<nstring,bufferptr> attrs;
void encode(bufferlist& bl) const {
break;
case CEPH_OSD_OP_MASKTRUNC:
case CEPH_OSD_OP_TRIMTRUNC:
- out << " " << op.op.extent.truncate_seq << "@" << (__s64)op.op.extent.truncate_size;
+ out << " " << op.op.extent.truncate_seq << "@" << (int64_t)op.op.extent.truncate_size;
break;
default:
out << " " << op.op.extent.offset << "~" << op.op.extent.length;
if (op.op.extent.truncate_seq)
- out << " [" << op.op.extent.truncate_seq << "@" << (__s64)op.op.extent.truncate_size << "]";
+ out << " [" << op.op.extent.truncate_seq << "@" << (int64_t)op.op.extent.truncate_size << "]";
}
} else if (ceph_osd_op_type_attr(op.op.op)) {
// xattr name
Filer *filer;
Probe *probe;
object_t oid;
- __u64 size;
+ uint64_t size;
utime_t mtime;
C_Probe(Filer *f, Probe *p, object_t o) : filer(f), probe(p), oid(o), size(0) {}
void finish(int r) {
int Filer::probe(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snapid,
- __u64 start_from,
- __u64 *end, // LB, when !fwd
+ uint64_t start_from,
+ uint64_t *end, // LB, when !fwd
utime_t *pmtime,
bool fwd,
int flags,
Probe *probe = new Probe(ino, *layout, snapid, start_from, end, pmtime, flags, fwd, onfinish);
// period (bytes before we jump unto a new set of object(s))
- __u64 period = layout->fl_stripe_count * layout->fl_object_size;
+ uint64_t period = layout->fl_stripe_count * layout->fl_object_size;
// start with 1+ periods.
probe->probing_len = period;
}
}
-void Filer::_probed(Probe *probe, const object_t& oid, __u64 size, utime_t mtime)
+void Filer::_probed(Probe *probe, const object_t& oid, uint64_t size, utime_t mtime)
{
dout(10) << "_probed " << probe->ino << " object " << oid
<< " has size " << size << " mtime " << mtime << dendl;
return; // waiting for more!
// analyze!
- __u64 end = 0;
+ uint64_t end = 0;
if (!probe->fwd) {
// reverse
for (vector<ObjectExtent>::iterator p = probe->probing.begin();
p != probe->probing.end();
p++) {
- __u64 shouldbe = p->length + p->offset;
+ uint64_t shouldbe = p->length + p->offset;
dout(10) << "_probed " << probe->ino << " object " << hex << p->oid << dec
<< " should be " << shouldbe
<< ", actual is " << probe->known_size[p->oid]
// aha, we found the end!
// calc offset into buffer_extent to get distance from probe->from.
- __u64 oleft = probe->known_size[p->oid] - p->offset;
+ uint64_t oleft = probe->known_size[p->oid] - p->offset;
for (map<__u32,__u32>::iterator i = p->buffer_extents.begin();
i != p->buffer_extents.end();
i++) {
- if (oleft <= (__u64)i->second) {
+ if (oleft <= (uint64_t)i->second) {
end = probe->probing_off + i->first + oleft;
dout(10) << "_probed end is in buffer_extent " << i->first << "~" << i->second << " off " << oleft
<< ", from was " << probe->probing_off << ", end is " << end
// keep probing!
dout(10) << "_probed probing further" << dendl;
- __u64 period = probe->layout.fl_stripe_count * probe->layout.fl_object_size;
+ uint64_t period = probe->layout.fl_stripe_count * probe->layout.fl_object_size;
if (probe->fwd) {
probe->probing_off += probe->probing_len;
assert(probe->probing_off % period == 0);
inodeno_t ino;
ceph_file_layout layout;
SnapContext snapc;
- __u64 first, num;
+ uint64_t first, num;
utime_t mtime;
int flags;
Context *oncommit;
int Filer::purge_range(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 first_obj, __u64 num_obj,
+ uint64_t first_obj, uint64_t num_obj,
utime_t mtime,
int flags,
Context *oncommit)
// -----------------------
void Filer::file_to_extents(inodeno_t ino, ceph_file_layout *layout,
- __u64 offset, __u64 len,
+ uint64_t offset, uint64_t len,
vector<ObjectExtent>& extents)
{
dout(10) << "file_to_extents " << offset << "~" << len
__u32 su = layout->fl_stripe_unit;
__u32 stripe_count = layout->fl_stripe_count;
assert(object_size >= su);
- __u64 stripes_per_object = object_size / su;
+ uint64_t stripes_per_object = object_size / su;
dout(20) << " stripes_per_object " << stripes_per_object << dendl;
- __u64 cur = offset;
- __u64 left = len;
+ uint64_t cur = offset;
+ uint64_t left = len;
while (left > 0) {
// layout into objects
- __u64 blockno = cur / su; // which block
- __u64 stripeno = blockno / stripe_count; // which horizontal stripe (Y)
- __u64 stripepos = blockno % stripe_count; // which object in the object set (X)
- __u64 objectsetno = stripeno / stripes_per_object; // which object set
- __u64 objectno = objectsetno * stripe_count + stripepos; // object id
+ uint64_t blockno = cur / su; // which block
+ uint64_t stripeno = blockno / stripe_count; // which horizontal stripe (Y)
+ uint64_t stripepos = blockno % stripe_count; // which object in the object set (X)
+ uint64_t objectsetno = stripeno / stripes_per_object; // which object set
+ uint64_t objectno = objectsetno * stripe_count + stripepos; // object id
// find oid, extent
ObjectExtent *ex = 0;
}
// map range into object
- __u64 block_start = (stripeno % stripes_per_object)*su;
- __u64 block_off = cur % su;
- __u64 max = su - block_off;
+ uint64_t block_start = (stripeno % stripes_per_object)*su;
+ uint64_t block_off = cur % su;
+ uint64_t max = su - block_off;
- __u64 x_offset = block_start + block_off;
- __u64 x_len;
+ uint64_t x_offset = block_start + block_off;
+ uint64_t x_len;
if (left > max)
x_len = max;
else
x_len = left;
- if (ex->offset + (__u64)ex->length == x_offset) {
+ if (ex->offset + (uint64_t)ex->length == x_offset) {
// add to extent
ex->length += x_len;
} else {
ceph_file_layout layout;
snapid_t snapid;
- __u64 *psize;
+ uint64_t *psize;
utime_t *pmtime;
int flags;
Context *onfinish;
vector<ObjectExtent> probing;
- __u64 probing_off, probing_len;
+ uint64_t probing_off, probing_len;
- map<object_t, __u64> known_size;
+ map<object_t, uint64_t> known_size;
utime_t max_mtime;
map<object_t, tid_t> ops;
bool found_size;
Probe(inodeno_t i, ceph_file_layout &l, snapid_t sn,
- __u64 f, __u64 *e, utime_t *m, int fl, bool fw, Context *c) :
+ uint64_t f, uint64_t *e, utime_t *m, int fl, bool fw, Context *c) :
ino(i), layout(l), snapid(sn),
psize(e), pmtime(m), flags(fl), fwd(fw), onfinish(c),
probing_off(f), probing_len(0),
class C_Probe;
void _probe(Probe *p);
- void _probed(Probe *p, const object_t& oid, __u64 size, utime_t mtime);
+ void _probed(Probe *p, const object_t& oid, uint64_t size, utime_t mtime);
public:
Filer(Objecter *o) : objecter(o) {}
* ranges in objects on (primary) osds)
*/
void file_to_extents(inodeno_t ino, ceph_file_layout *layout,
- __u64 offset, __u64 len,
+ uint64_t offset, uint64_t len,
vector<ObjectExtent>& extents);
int read(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
bufferlist *bl, // ptr to data
int flags,
Context *onfinish) {
int read_trunc(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
bufferlist *bl, // ptr to data
int flags,
- __u64 truncate_size,
+ uint64_t truncate_size,
__u32 truncate_seq,
Context *onfinish) {
assert(snap); // (until there is a non-NOSNAP write)
int write(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
bufferlist& bl,
utime_t mtime,
int flags,
int write_trunc(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
bufferlist& bl,
utime_t mtime,
int flags,
- __u64 truncate_size,
+ uint64_t truncate_size,
__u32 truncate_seq,
Context *onack,
Context *oncommit) {
int truncate(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
__u32 truncate_seq,
utime_t mtime,
int flags,
int zero(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 offset,
- __u64 len,
+ uint64_t offset,
+ uint64_t len,
utime_t mtime,
int flags,
Context *onack,
int purge_range(inodeno_t ino,
ceph_file_layout *layout,
const SnapContext& snapc,
- __u64 first_obj, __u64 num_obj,
+ uint64_t first_obj, uint64_t num_obj,
utime_t mtime,
int flags,
Context *oncommit);
int probe(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snapid,
- __u64 start_from,
- __u64 *end,
+ uint64_t start_from,
+ uint64_t *end,
utime_t *mtime,
bool fwd,
int flags,
class Journaler::C_ProbeEnd : public Context {
Journaler *ls;
public:
- __s64 end;
+ int64_t end;
C_ProbeEnd(Journaler *l) : ls(l), end(-1) {}
void finish(int r) {
ls->_finish_probe_end(r, end);
state = STATE_PROBING;
C_ProbeEnd *fin = new C_ProbeEnd(this);
filer.probe(ino, &layout, CEPH_NOSNAP,
- h.write_pos, (__u64 *)&fin->end, 0, true, 0, fin);
+ h.write_pos, (uint64_t *)&fin->end, 0, true, 0, fin);
}
-void Journaler::_finish_probe_end(int r, __s64 end)
+void Journaler::_finish_probe_end(int r, int64_t end)
{
assert(state == STATE_PROBING);
class Journaler::C_Flush : public Context {
Journaler *ls;
- __s64 start;
+ int64_t start;
utime_t stamp;
bool safe;
public:
- C_Flush(Journaler *l, __s64 s, utime_t st, bool sa) : ls(l), start(s), stamp(st), safe(sa) {}
+ C_Flush(Journaler *l, int64_t s, utime_t st, bool sa) : ls(l), start(s), stamp(st), safe(sa) {}
void finish(int r) { ls->_finish_flush(r, start, stamp, safe); }
};
-void Journaler::_finish_flush(int r, __s64 start, utime_t stamp, bool safe)
+void Journaler::_finish_flush(int r, int64_t start, utime_t stamp, bool safe)
{
assert(r>=0);
}
-__s64 Journaler::append_entry(bufferlist& bl)
+int64_t Journaler::append_entry(bufferlist& bl)
{
uint32_t s = bl.length();
if (!g_conf.journaler_allow_split_entries) {
// will we span a stripe boundary?
int p = layout.fl_stripe_unit;
- if (write_pos / p != (write_pos + (__s64)(bl.length() + sizeof(s))) / p) {
+ if (write_pos / p != (write_pos + (int64_t)(bl.length() + sizeof(s))) / p) {
// yes.
// move write_pos forward.
- __s64 owp = write_pos;
+ int64_t owp = write_pos;
write_pos += p;
write_pos -= (write_pos % p);
* then discover we need even more for an especially large entry.
* i don't think that circumstance will arise particularly often.
*/
-void Journaler::_issue_read(__s64 len)
+void Journaler::_issue_read(int64_t len)
{
// make sure we're fully flushed
_do_flush();
void Journaler::_prefetch()
{
// prefetch?
- __s64 left = requested_pos - read_pos;
+ int64_t left = requested_pos - read_pos;
if (left <= prefetch_from && // should read more,
!_is_reading() && // and not reading anything right now
write_pos > requested_pos) { // there's something more to read...
// start reading some more?
if (!_is_reading()) {
if (s)
- fetch_len = MAX(fetch_len, (__s64)(sizeof(s)+s-read_buf.length()));
+ fetch_len = MAX(fetch_len, (int64_t)(sizeof(s)+s-read_buf.length()));
_issue_read(fetch_len);
}
return true;
}
- __s64 len = junk_tail_pos - write_pos;
+ int64_t len = junk_tail_pos - write_pos;
dout(10) << "truncate_tail_junk " << write_pos << "~" << len << dendl;
SnapContext snapc;
filer.zero(ino, &layout, snapc, write_pos, len, g_clock.now(), 0, NULL, c);
class Journaler::C_Trim : public Context {
Journaler *ls;
- __s64 to;
+ int64_t to;
public:
- C_Trim(Journaler *l, __s64 t) : ls(l), to(t) {}
+ C_Trim(Journaler *l, int64_t t) : ls(l), to(t) {}
void finish(int r) {
ls->_trim_finish(r, to);
}
void Journaler::trim()
{
- __u64 period = layout.fl_stripe_count * layout.fl_object_size;
+ uint64_t period = layout.fl_stripe_count * layout.fl_object_size;
- __s64 trim_to = last_committed.expire_pos;
+ int64_t trim_to = last_committed.expire_pos;
trim_to -= trim_to % period;
dout(10) << "trim last_commited head was " << last_committed
<< ", can trim to " << trim_to
<< dendl;
// delete range of objects
- __u64 first = trimming_pos / period;
- __u64 num = (trim_to - trimming_pos) / period;
+ uint64_t first = trimming_pos / period;
+ uint64_t num = (trim_to - trimming_pos) / period;
SnapContext snapc;
filer.purge_range(ino, &layout, snapc, first, num, g_clock.now(), 0,
new C_Trim(this, trim_to));
trimming_pos = trim_to;
}
-void Journaler::_trim_finish(int r, __s64 to)
+void Journaler::_trim_finish(int r, int64_t to)
{
dout(10) << "_trim_finish trimmed_pos was " << trimmed_pos
<< ", trimmed/trimming/expire now "
public:
// this goes at the head of the log "file".
struct Header {
- __s64 trimmed_pos;
- __s64 expire_pos;
- __s64 read_pos;
- __s64 write_pos;
+ int64_t trimmed_pos;
+ int64_t expire_pos;
+ int64_t read_pos;
+ int64_t write_pos;
nstring magic;
ceph_file_layout layout;
list<Context*> waitfor_recover;
void _finish_read_head(int r, bufferlist& bl);
- void _finish_probe_end(int r, __s64 end);
+ void _finish_probe_end(int r, int64_t end);
class C_ReadHead;
friend class C_ReadHead;
class C_ProbeEnd;
// writer
- __s64 write_pos; // logical write position, where next entry will go
- __s64 flush_pos; // where we will flush. if write_pos>flush_pos, we're buffering writes.
- __s64 ack_pos; // what has been acked.
- __s64 safe_pos; // what has been committed safely to disk.
+ int64_t write_pos; // logical write position, where next entry will go
+ int64_t flush_pos; // where we will flush. if write_pos>flush_pos, we're buffering writes.
+ int64_t ack_pos; // what has been acked.
+ int64_t safe_pos; // what has been committed safely to disk.
bufferlist write_buf; // write buffer. flush_pos + write_buf.length() == write_pos.
- std::set<__s64> pending_ack, pending_safe;
- std::map<__s64, std::list<Context*> > waitfor_ack; // when flushed through given offset
- std::map<__s64, std::list<Context*> > waitfor_safe; // when safe through given offset
- std::set<__s64> ack_barrier;
+ std::set<int64_t> pending_ack, pending_safe;
+ std::map<int64_t, std::list<Context*> > waitfor_ack; // when flushed through given offset
+ std::map<int64_t, std::list<Context*> > waitfor_safe; // when safe through given offset
+ std::set<int64_t> ack_barrier;
void _do_flush(unsigned amount=0);
- void _finish_flush(int r, __s64 start, utime_t stamp, bool safe);
+ void _finish_flush(int r, int64_t start, utime_t stamp, bool safe);
class C_Flush;
friend class C_Flush;
// reader
- __s64 read_pos; // logical read position, where next entry starts.
- __s64 requested_pos; // what we've requested from OSD.
- __s64 received_pos; // what we've received from OSD.
+ int64_t read_pos; // logical read position, where next entry starts.
+ int64_t requested_pos; // what we've requested from OSD.
+ int64_t received_pos; // what we've received from OSD.
bufferlist read_buf; // read buffer. read_pos + read_buf.length() == prefetch_pos.
bufferlist reading_buf; // what i'm reading into
- __s64 fetch_len; // how much to read at a time
- __s64 prefetch_from; // how far from end do we read next chunk
+ int64_t fetch_len; // how much to read at a time
+ int64_t prefetch_from; // how far from end do we read next chunk
- __s64 junk_tail_pos; // for truncate
+ int64_t junk_tail_pos; // for truncate
// for read_entry() in-progress read
bufferlist *read_bl;
return requested_pos > received_pos;
}
void _finish_read(int r); // we just read some (read completion callback)
- void _issue_read(__s64 len); // read some more
+ void _issue_read(int64_t len); // read some more
void _prefetch(); // maybe read ahead
class C_Read;
friend class C_Read;
friend class C_RetryRead;
// trimmer
- __s64 expire_pos; // what we're allowed to trim to
- __s64 trimming_pos; // what we've requested to trim through
- __s64 trimmed_pos; // what has been trimmed
- map<__s64, list<Context*> > waitfor_trim;
+ int64_t expire_pos; // what we're allowed to trim to
+ int64_t trimming_pos; // what we've requested to trim through
+ int64_t trimmed_pos; // what has been trimmed
+ map<int64_t, list<Context*> > waitfor_trim;
- void _trim_finish(int r, __s64 to);
+ void _trim_finish(int r, int64_t to);
class C_Trim;
friend class C_Trim;
bool is_active() { return state == STATE_ACTIVE; }
int get_error() { return error; }
- __s64 get_write_pos() const { return write_pos; }
- __s64 get_write_ack_pos() const { return ack_pos; }
- __s64 get_write_safe_pos() const { return safe_pos; }
- __s64 get_read_pos() const { return read_pos; }
- __s64 get_expire_pos() const { return expire_pos; }
- __s64 get_trimmed_pos() const { return trimmed_pos; }
+ int64_t get_write_pos() const { return write_pos; }
+ int64_t get_write_ack_pos() const { return ack_pos; }
+ int64_t get_write_safe_pos() const { return safe_pos; }
+ int64_t get_read_pos() const { return read_pos; }
+ int64_t get_expire_pos() const { return expire_pos; }
+ int64_t get_trimmed_pos() const { return trimmed_pos; }
- __s64 get_layout_period() const { return layout.fl_stripe_count * layout.fl_object_size; }
+ int64_t get_layout_period() const { return layout.fl_stripe_count * layout.fl_object_size; }
ceph_file_layout& get_layout() { return layout; }
// write
- __s64 append_entry(bufferlist& bl);
+ int64_t append_entry(bufferlist& bl);
void wait_for_flush(Context *onsync = 0, Context *onsafe = 0, bool add_ack_barrier=false);
void flush(Context *onsync = 0, Context *onsafe = 0, bool add_ack_barrier=false);
// read
- void set_read_pos(__s64 p) {
+ void set_read_pos(int64_t p) {
assert(requested_pos == received_pos); // we can't cope w/ in-progress read right now.
assert(read_bl == 0); // ...
read_pos = requested_pos = received_pos = p;
bool truncate_tail_junk(Context *fin);
// trim
- void set_expire_pos(__s64 ep) { expire_pos = ep; }
+ void set_expire_pos(int64_t ep) { expire_pos = ep; }
void trim();
//bool is_trimmable() { return trimming_pos < expire_pos; }
- //void trim(__s64 trim_to=0, Context *c=0);
+ //void trim(int64_t trim_to=0, Context *c=0);
};
WRITE_CLASS_ENCODER(Journaler::Header)
onfinish);
}
-void ObjectCacher::bh_read_finish(sobject_t oid, loff_t start, __u64 length, bufferlist &bl)
+void ObjectCacher::bh_read_finish(sobject_t oid, loff_t start, uint64_t length, bufferlist &bl)
{
//lock.Lock();
dout(7) << "bh_read_finish "
}
}
-void ObjectCacher::bh_write_ack(sobject_t oid, loff_t start, __u64 length, tid_t tid)
+void ObjectCacher::bh_write_ack(sobject_t oid, loff_t start, uint64_t length, tid_t tid)
{
//lock.Lock();
//lock.Unlock();
}
-void ObjectCacher::bh_write_commit(sobject_t oid, loff_t start, __u64 length, tid_t tid)
+void ObjectCacher::bh_write_commit(sobject_t oid, loff_t start, uint64_t length, tid_t tid)
{
//lock.Lock();
{
bool success = true;
list<BufferHead*> hit_ls;
- map<__u64, bufferlist> stripe_map; // final buffer offset -> substring
+ map<uint64_t, bufferlist> stripe_map; // final buffer offset -> substring
for (vector<ObjectExtent>::iterator ex_it = rd->extents.begin();
ex_it != rd->extents.end();
loff_t opos = ex_it->offset;
map<loff_t, BufferHead*>::iterator bh_it = hits.begin();
assert(bh_it->second->start() <= opos);
- __u64 bhoff = opos - bh_it->second->start();
+ uint64_t bhoff = opos - bh_it->second->start();
map<__u32,__u32>::iterator f_it = ex_it->buffer_extents.begin();
- __u64 foff = 0;
+ uint64_t foff = 0;
while (1) {
BufferHead *bh = bh_it->second;
assert(opos == (loff_t)(bh->start() + bhoff));
<< " frag " << f_it->first << "~" << f_it->second << " +" << foff
<< dendl;
- __u64 len = MIN(f_it->second - foff,
+ uint64_t len = MIN(f_it->second - foff,
bh->length() - bhoff);
bufferlist bit; // put substr here first, since substr_of clobbers, and
// we may get multiple bh's at this stripe_map position
dout(10) << "readx has all buffers" << dendl;
// ok, assemble into result buffer.
- __u64 pos = 0;
+ uint64_t pos = 0;
if (rd->bl) {
rd->bl->clear();
- for (map<__u64,bufferlist>::iterator i = stripe_map.begin();
+ for (map<uint64_t,bufferlist>::iterator i = stripe_map.begin();
i != stripe_map.end();
i++) {
assert(pos == i->first);
f_it != ex_it->buffer_extents.end();
f_it++) {
dout(10) << "writex writing " << f_it->first << "~" << f_it->second << " into " << *bh << " at " << opos << dendl;
- __u64 bhoff = bh->start() - opos;
+ uint64_t bhoff = bh->start() - opos;
assert(f_it->second <= bh->length() - bhoff);
// get the frag we're mapping in
// blocking wait for write.
-bool ObjectCacher::wait_for_write(__u64 len, Mutex& lock)
+bool ObjectCacher::wait_for_write(uint64_t len, Mutex& lock)
{
int blocked = 0;
}
-__u64 ObjectCacher::release_all()
+uint64_t ObjectCacher::release_all()
{
dout(10) << "release_all" << dendl;
- __u64 unclean = 0;
+ uint64_t unclean = 0;
hash_map<sobject_t, Object*>::iterator p = objects.begin();
while (p != objects.end()) {
void *parent;
inodeno_t ino;
- __u64 truncate_seq, truncate_size;
+ uint64_t truncate_seq, truncate_size;
xlist<Object*> objects;
xlist<Object*> uncommitted;
void wrunlock(Object *o);
public:
- void bh_read_finish(sobject_t oid, loff_t offset, __u64 length, bufferlist &bl);
- void bh_write_ack(sobject_t oid, loff_t offset, __u64 length, tid_t t);
- void bh_write_commit(sobject_t oid, loff_t offset, __u64 length, tid_t t);
+ void bh_read_finish(sobject_t oid, loff_t offset, uint64_t length, bufferlist &bl);
+ void bh_write_ack(sobject_t oid, loff_t offset, uint64_t length, tid_t t);
+ void bh_write_commit(sobject_t oid, loff_t offset, uint64_t length, tid_t t);
void lock_ack(list<sobject_t>& oids, tid_t tid);
class C_ReadFinish : public Context {
ObjectCacher *oc;
sobject_t oid;
loff_t start;
- __u64 length;
+ uint64_t length;
public:
bufferlist bl;
- C_ReadFinish(ObjectCacher *c, sobject_t o, loff_t s, __u64 l) : oc(c), oid(o), start(s), length(l) {}
+ C_ReadFinish(ObjectCacher *c, sobject_t o, loff_t s, uint64_t l) : oc(c), oid(o), start(s), length(l) {}
void finish(int r) {
oc->bh_read_finish(oid, start, length, bl);
}
ObjectCacher *oc;
sobject_t oid;
loff_t start;
- __u64 length;
+ uint64_t length;
public:
tid_t tid;
- C_WriteAck(ObjectCacher *c, sobject_t o, loff_t s, __u64 l) : oc(c), oid(o), start(s), length(l) {}
+ C_WriteAck(ObjectCacher *c, sobject_t o, loff_t s, uint64_t l) : oc(c), oid(o), start(s), length(l) {}
void finish(int r) {
oc->bh_write_ack(oid, start, length, tid);
}
ObjectCacher *oc;
sobject_t oid;
loff_t start;
- __u64 length;
+ uint64_t length;
public:
tid_t tid;
- C_WriteCommit(ObjectCacher *c, sobject_t o, loff_t s, __u64 l) : oc(c), oid(o), start(s), length(l) {}
+ C_WriteCommit(ObjectCacher *c, sobject_t o, loff_t s, uint64_t l) : oc(c), oid(o), start(s), length(l) {}
void finish(int r) {
oc->bh_write_commit(oid, start, length, tid);
}
bool is_cached(ObjectSet *oset, vector<ObjectExtent>& extents, snapid_t snapid);
// write blocking
- bool wait_for_write(__u64 len, Mutex& lock);
+ bool wait_for_write(uint64_t len, Mutex& lock);
// blocking. atomic+sync.
int atomic_sync_readx(OSDRead *rd, ObjectSet *oset, Mutex& lock);
void purge_set(ObjectSet *oset);
loff_t release_set(ObjectSet *oset); // returns # of bytes not released (ie non-clean)
- __u64 release_all();
+ uint64_t release_all();
void truncate_set(ObjectSet *oset, vector<ObjectExtent>& ex);
/*** async+caching (non-blocking) file interface ***/
int file_is_cached(ObjectSet *oset, ceph_file_layout *layout, snapid_t snapid,
- loff_t offset, __u64 len) {
+ loff_t offset, uint64_t len) {
vector<ObjectExtent> extents;
filer.file_to_extents(oset->ino, layout, offset, len, extents);
return is_cached(oset, extents, snapid);
}
int file_read(ObjectSet *oset, ceph_file_layout *layout, snapid_t snapid,
- loff_t offset, __u64 len,
+ loff_t offset, uint64_t len,
bufferlist *bl,
int flags,
Context *onfinish) {
}
int file_write(ObjectSet *oset, ceph_file_layout *layout, const SnapContext& snapc,
- loff_t offset, __u64 len,
+ loff_t offset, uint64_t len,
bufferlist& bl, utime_t mtime, int flags) {
OSDWrite *wr = prepare_write(snapc, bl, mtime, flags);
filer.file_to_extents(oset->ino, layout, offset, len, wr->extents);
int file_atomic_sync_read(ObjectSet *oset, ceph_file_layout *layout,
snapid_t snapid,
- loff_t offset, __u64 len,
+ loff_t offset, uint64_t len,
bufferlist *bl, int flags,
Mutex &lock) {
OSDRead *rd = prepare_read(snapid, bl, flags);
int file_atomic_sync_write(ObjectSet *oset, ceph_file_layout *layout,
const SnapContext& snapc,
- loff_t offset, __u64 len,
+ loff_t offset, uint64_t len,
bufferlist& bl, utime_t mtime, int flags,
Mutex &lock) {
OSDWrite *wr = prepare_write(snapc, bl, mtime, flags);
bufferlist::iterator iter = bl->begin();
PGLSResponse response;
::decode(response, iter);
- list_context->cookie = (__u64)response.handle;
+ list_context->cookie = (uint64_t)response.handle;
int response_size = response.entries.size();
dout(20) << "response.entries.size " << response_size
return 0;
}
-int Objecter::create_pool(string& name, Context *onfinish, __u64 auid)
+int Objecter::create_pool(string& name, Context *onfinish, uint64_t auid)
{
dout(10) << "create_pool name=" << name << dendl;
PoolOp *op = new PoolOp;
* on both the pool's current auid and the new (parameter) auid.
* Uses the standard Context callback when done.
*/
-int Objecter::change_pool_auid(int pool, Context *onfinish, __u64 auid)
+int Objecter::change_pool_auid(int pool, Context *onfinish, uint64_t auid)
{
dout(10) << "change_pool_auid " << pool << " to " << auid << dendl;
PoolOp *op = new PoolOp;
bufferlist *bl, Context *onfinish)
{
// all done
- __u64 bytes_read = 0;
+ uint64_t bytes_read = 0;
dout(15) << "_sg_read_finish" << dendl;
*/
// map extents back into buffer
- map<__u64, bufferlist*> by_off; // buffer offset -> bufferlist
+ map<uint64_t, bufferlist*> by_off; // buffer offset -> bufferlist
// for each object extent...
vector<bufferlist>::iterator bit = resultbl.begin();
}
// sort and string bits together
- for (map<__u64, bufferlist*>::iterator it = by_off.begin();
+ for (map<uint64_t, bufferlist*>::iterator it = by_off.begin();
it != by_off.end();
it++) {
assert(it->second->length());
- if (it->first < (__u64)bytes_read) {
+ if (it->first < (uint64_t)bytes_read) {
dout(21) << " concat buffer frag off " << it->first << " len " << it->second->length() << dendl;
bl->claim_append(*(it->second));
} else {
ops.resize(s+1);
ops[s].op.op = op;
}
- void add_data(int op, __u64 off, __u64 len, bufferlist& bl) {
+ void add_data(int op, uint64_t off, uint64_t len, bufferlist& bl) {
int s = ops.size();
ops.resize(s+1);
ops[s].op.op = op;
ops[s].data.append(method, ops[s].op.cls.method_len);
ops[s].data.append(indata);
}
- void add_pgls(int op, __u64 count, __u64 cookie) {
+ void add_pgls(int op, uint64_t count, uint64_t cookie) {
int s = ops.size();
ops.resize(s+1);
ops[s].op.op = op;
// ------
// pg
- void pg_ls(__u64 count, __u64 cookie) {
+ void pg_ls(uint64_t count, uint64_t cookie) {
add_pgls(CEPH_OSD_OP_PGLS, count, cookie);
flags |= CEPH_OSD_FLAG_PGOP;
}
// object data
- void read(__u64 off, __u64 len) {
+ void read(uint64_t off, uint64_t len) {
bufferlist bl;
add_data(CEPH_OSD_OP_READ, off, len, bl);
}
- void write(__u64 off, __u64 len, bufferlist& bl) {
+ void write(uint64_t off, uint64_t len, bufferlist& bl) {
add_data(CEPH_OSD_OP_WRITE, off, len, bl);
}
void write_full(bufferlist& bl) {
add_data(CEPH_OSD_OP_WRITEFULL, 0, bl.length(), bl);
}
- void zero(__u64 off, __u64 len) {
+ void zero(uint64_t off, uint64_t len) {
bufferlist bl;
add_data(CEPH_OSD_OP_ZERO, off, len, bl);
}
struct C_Stat : public Context {
bufferlist bl;
- __u64 *psize;
+ uint64_t *psize;
utime_t *pmtime;
Context *fin;
- C_Stat(__u64 *ps, utime_t *pm, Context *c) :
+ C_Stat(uint64_t *ps, utime_t *pm, Context *c) :
psize(ps), pmtime(pm), fin(c) {}
void finish(int r) {
if (r >= 0) {
bufferlist::iterator p = bl.begin();
- __u64 s;
+ uint64_t s;
utime_t m;
::decode(s, p);
::decode(m, p);
// Pools and statistics
struct ListContext {
int current_pg;
- __u64 cookie;
+ uint64_t cookie;
int starting_pg_num;
bool at_end;
Context *onfinish;
int pool_op;
int* replyCode;
- __u64 auid;
+ uint64_t auid;
utime_t last_submit;
PoolOp() : tid(0), pool(0), onfinish(0), pool_op(0),
// high-level helpers
tid_t stat(const object_t& oid, ceph_object_layout ol, snapid_t snap,
- __u64 *psize, utime_t *pmtime, int flags,
+ uint64_t *psize, utime_t *pmtime, int flags,
Context *onfinish) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_STAT;
}
tid_t read(const object_t& oid, ceph_object_layout ol,
- __u64 off, __u64 len, snapid_t snap, bufferlist *pbl, int flags,
+ uint64_t off, uint64_t len, snapid_t snap, bufferlist *pbl, int flags,
Context *onfinish) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_READ;
return op_submit(o);
}
tid_t read_trunc(const object_t& oid, ceph_object_layout ol,
- __u64 off, __u64 len, snapid_t snap, bufferlist *pbl, int flags,
- __u64 trunc_size, __u32 trunc_seq,
+ uint64_t off, uint64_t len, snapid_t snap, bufferlist *pbl, int flags,
+ uint64_t trunc_size, __u32 trunc_seq,
Context *onfinish) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_READ;
return op_submit(o);
}
tid_t write(const object_t& oid, ceph_object_layout ol,
- __u64 off, __u64 len, const SnapContext& snapc, const bufferlist &bl,
+ uint64_t off, uint64_t len, const SnapContext& snapc, const bufferlist &bl,
utime_t mtime, int flags,
Context *onack, Context *oncommit) {
vector<OSDOp> ops(1);
return op_submit(o);
}
tid_t write_trunc(const object_t& oid, ceph_object_layout ol,
- __u64 off, __u64 len, const SnapContext& snapc, const bufferlist &bl,
+ uint64_t off, uint64_t len, const SnapContext& snapc, const bufferlist &bl,
utime_t mtime, int flags,
- __u64 trunc_size, __u32 trunc_seq,
+ uint64_t trunc_size, __u32 trunc_seq,
Context *onack, Context *oncommit) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_WRITE;
return op_submit(o);
}
tid_t zero(const object_t& oid, ceph_object_layout ol,
- __u64 off, __u64 len, const SnapContext& snapc, utime_t mtime, int flags,
+ uint64_t off, uint64_t len, const SnapContext& snapc, utime_t mtime, int flags,
Context *onack, Context *oncommit) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_ZERO;
int create_pool_snap(int pool, string& snapName, Context *onfinish);
int delete_pool_snap(int pool, string& snapName, Context *onfinish);
- int create_pool(string& name, Context *onfinish, __u64 auid=0);
+ int create_pool(string& name, Context *onfinish, uint64_t auid=0);
int delete_pool(int pool, Context *onfinish);
- int change_pool_auid(int pool, Context *onfinish, __u64 auid);
+ int change_pool_auid(int pool, Context *onfinish, uint64_t auid);
void handle_pool_op_reply(MPoolOpReply *m);
};
void sg_read_trunc(vector<ObjectExtent>& extents, snapid_t snap, bufferlist *bl, int flags,
- __u64 trunc_size, __u32 trunc_seq, Context *onfinish) {
+ uint64_t trunc_size, __u32 trunc_seq, Context *onfinish) {
if (extents.size() == 1) {
read_trunc(extents[0].oid, extents[0].layout, extents[0].offset, extents[0].length,
snap, bl, flags, trunc_size, trunc_seq, onfinish);
}
void sg_write_trunc(vector<ObjectExtent>& extents, const SnapContext& snapc, const bufferlist& bl, utime_t mtime,
- int flags, __u64 trunc_size, __u32 trunc_seq,
+ int flags, uint64_t trunc_size, __u32 trunc_seq,
Context *onack, Context *oncommit) {
if (extents.size() == 1) {
write_trunc(extents[0].oid, extents[0].layout, extents[0].offset, extents[0].length,
}
}
- __u64 avg = 0;
+ uint64_t avg = 0;
for (int i=0; i<n; i++) {
cout << "osd" << i << "\t" << count[i] << std::endl;
avg += count[i];
if (!pool || nargs.size() < 2)
usage();
- __u64 new_auid = strtol(nargs[1], 0, 10);
+ uint64_t new_auid = strtol(nargs[1], 0, 10);
ret = rados.change_pool_auid(p, new_auid);
if (ret < 0) {
cerr << "error changing auid on pool " << pool << ':'
<< std::endl;
}
-void trim_image(const char *imgname, rbd_obj_header_ondisk *header, __u64 newsize)
+void trim_image(const char *imgname, rbd_obj_header_ondisk *header, uint64_t newsize)
{
- __u64 size = header->image_size;
- __u64 numseg = size >> header->obj_order;
- __u64 start = newsize >> header->obj_order;
+ uint64_t size = header->image_size;
+ uint64_t numseg = size >> header->obj_order;
+ uint64_t start = newsize >> header->obj_order;
cout << "trimming image data from " << numseg << " to " << start << " objects..." << std::endl;
- for (__u64 i=start; i<numseg; i++) {
+ for (uint64_t i=start; i<numseg; i++) {
char o[RBD_MAX_SEG_NAME_SIZE];
sprintf(o, "%s.%012llx", imgname, (unsigned long long)i);
string oid = o;
bool opt_create = false, opt_delete = false, opt_list = false, opt_info = false, opt_resize = false;
char *poolname = (char *)"rbd";
- __u64 size = 0;
+ uint64_t size = 0;
int order = 0;
char *imgname;
std::string& marker, std::vector<RGWObjEnt>& result, map<string, bool>& common_prefixes) = 0;
/** Create a new bucket*/
- virtual int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, __u64 auid=0) = 0;
+ virtual int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid=0) = 0;
/** write an object to the storage device in the appropriate pool
with the given stats */
virtual int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
bool list_buckets = false;
bool delete_user = false;
int actions = 0 ;
- __u64 auid = 0;
+ uint64_t auid = 0;
RGWUserInfo info;
RGWAccess *store;
#define RGW_ATTR_CONTENT_TYPE RGW_ATTR_PREFIX "content_type"
#define USER_INFO_VER 2
-#define CEPH_AUTH_UID_DEFAULT (__u64) -1
+#define CEPH_AUTH_UID_DEFAULT (uint64_t) -1
typedef void *RGWAccessHandle;
struct RGWUserInfo
{
- __u64 auid;
+ uint64_t auid;
string user_id;
string secret_key;
string display_name;
void encode(bufferlist& bl) const {
__u8 struct_v = 1;
::encode(struct_v, bl);
- __u64 s = size;
+ uint64_t s = size;
__u32 mt = mtime;
::encode(name, bl);
::encode(s, bl);
__u8 struct_v;
::decode(struct_v, bl);
__u32 mt;
- __u64 s;
+ uint64_t s;
::decode(name, bl);
::decode(s, bl);
::decode(mt, bl);
}
-int RGWFS::create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, __u64 auid)
+int RGWFS::create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1;
char buf[len];
int list_objects(std::string& id, std::string& bucket, int max, std::string& prefix, std::string& delim,
std::string& marker, std::vector<RGWObjEnt>& result, map<string, bool>& common_prefixes);
- int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, __u64 auid=0);
+ int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid=0);
int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
time_t *mtime,
map<std::string, bufferlist>& attrs);
}
}
- __u64 s;
+ uint64_t s;
if (rados->stat(pool, *p, &s, &obj.mtime) < 0)
continue;
obj.size = s;
* if auid is set, it sets the auid of the underlying rados pool
* returns 0 on success, -ERR# otherwise.
*/
-int RGWRados::create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, __u64 auid)
+int RGWRados::create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid)
{
int ret = rados->create(root_pool, bucket, true);
if (ret < 0)
struct rgw_err *err)
{
int r = -EINVAL;
- __u64 size, len;
+ uint64_t size, len;
bufferlist etag;
time_t mtime;
bufferlist bl;
* create a bucket with name bucket and the given list of attrs
* returns 0 on success, -ERR# otherwise.
*/
- int create_bucket(std::string& id, std::string& bucket, map<std::string,bufferlist>& attrs, __u64 auid=0);
+ int create_bucket(std::string& id, std::string& bucket, map<std::string,bufferlist>& attrs, uint64_t auid=0);
/** Write/overwrite an object to the bucket storage. */
int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
Mutex lock("mylock");
Cond cond;
-__u64 received = 0;
+uint64_t received = 0;
class Admin : public Dispatcher {
bool ms_dispatch(Message *m) {
isend = 100;
lock.Lock();
- __u64 sent = 0;
+ uint64_t sent = 0;
while (1) {
while (received + isend <= sent) {
//cerr << "wait r " << received << " s " << sent << " is " << isend << std::endl;
projects / ceph.git / commitdiff