int64_t ol = t.get_int();
object_t oid(oh, ol);
lock.Lock();
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
off_t size;
client->objecter->stat(oid, &size, layout, new C_SafeCond(&lock, &cond, &ack));
while (!ack) cond.Wait(lock);
int64_t len = t.get_int();
object_t oid(oh, ol);
lock.Lock();
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
bufferlist bl;
client->objecter->read(oid, off, len, layout, &bl, new C_SafeCond(&lock, &cond, &ack));
while (!ack) cond.Wait(lock);
int64_t len = t.get_int();
object_t oid(oh, ol);
lock.Lock();
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
bufferptr bp(len);
bufferlist bl;
bl.push_back(bp);
int64_t len = t.get_int();
object_t oid(oh, ol);
lock.Lock();
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2);
client->objecter->zero(oid, off, len, layout,
new C_SafeCond(&lock, &cond, &ack),
safeg->new_sub());
if (time_to_stop()) break;
object_t oid(0x1000, i);
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, g_OSD_FileLayout.fl_pg_size);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, g_OSD_FileLayout.fl_pg_size);
if (i % inflight == 0) {
dout(6) << "create_objects " << i << "/" << (nobj+1) << dendl;
}
object_t oid(0x1000, o);
- ceph_object_layout_t layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, g_OSD_FileLayout.fl_pg_size);
+ ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, g_OSD_FileLayout.fl_pg_size);
client->client_lock.Lock();
utime_t start = g_clock.now();
__u64 major;
__u64 minor;
};
-typedef struct ceph_fsid ceph_fsid_t;
-static inline int ceph_fsid_equal(const ceph_fsid_t *a, const ceph_fsid_t *b) {
+static inline int ceph_fsid_equal(const struct ceph_fsid *a, const struct ceph_fsid *b) {
return a->major == b->major && a->minor == b->minor;
}
__u32 bno; /* "block" (object) in that "file" */
__u32 rev; /* revision. normally ctime (as epoch). */
};
-typedef struct ceph_object ceph_object_t;
#define CEPH_INO_ROOT 1
__u8 size;
} pg;
};
-typedef union ceph_pg ceph_pg_t;
#define ceph_pg_is_rep(pg) (pg.pg.type == CEPH_PG_TYPE_REP)
#define ceph_pg_is_raid4(pg) (pg.pg.type == CEPH_PG_TYPE_RAID4)
* object layout - how a given object should be stored.
*/
struct ceph_object_layout {
- ceph_pg_t pgid;
- __u32 stripe_unit;
+ union ceph_pg pgid;
+ __u32 stripe_unit;
} __attribute__ ((packed));
-typedef struct ceph_object_layout ceph_object_layout_t;
/*
* compound epoch+version, used by rados to serialize mutations
ceph_epoch_t epoch;
__u64 version;
} __attribute__ ((packed));
-typedef struct ceph_eversion ceph_eversion_t;
/*
* osd map bits
float frac_rd_ops_shed_in;
float frac_rd_ops_shed_out;
} __attribute__ ((packed));
-typedef struct ceph_osd_peer_stat ceph_osd_peer_stat_t;
struct ceph_osd_request_head {
struct ceph_entity_inst client_inst;
__u32 client_inc;
__u32 op;
__u64 offset, length;
- ceph_object_t oid;
- ceph_object_layout_t layout;
+ struct ceph_object oid;
+ struct ceph_object_layout layout;
ceph_epoch_t osdmap_epoch;
__u32 flags;
- ceph_eversion_t reassert_version;
+ struct ceph_eversion reassert_version;
/* semi-hack, fix me */
- __u32 shed_count;
- ceph_osd_peer_stat_t peer_stat;
+ __u32 shed_count;
+ struct ceph_osd_peer_stat peer_stat;
} __attribute__ ((packed));
struct ceph_osd_reply_head {
ceph_tid_t tid;
__u32 op;
__u32 flags;
- ceph_object_t oid;
- ceph_object_layout_t layout;
+ struct ceph_object oid;
+ struct ceph_object_layout layout;
ceph_epoch_t osdmap_epoch;
__s32 result;
__u64 offset, length;
- ceph_eversion_t reassert_version;
+ struct ceph_eversion reassert_version;
} __attribute__ ((packed));
#endif
bno = co.bno;
rev = co.rev;
}
- operator ceph_object_t() {
- ceph_object_t oid;
+ operator ceph_object() {
+ ceph_object oid;
oid.ino = ino;
oid.bno = bno;
oid.rev = rev;
// --
-inline ostream& operator<<(ostream& out, ceph_fsid_t& f) {
+inline ostream& operator<<(ostream& out, ceph_fsid& f) {
return out << hex << f.major << '.' << f.minor << dec;
}
struct ceph_osd_client {
spinlock_t lock;
- struct ceph_client *client;
+ struct ceph_client *client;
struct ceph_osdmap *osdmap; /* current map */
__u64 last_requested_map;
__u64 last_tid; /* tid of last request */
object_t get_oid() { return object_t(head.oid); }
pg_t get_pg() { return head.layout.pgid; }
- ceph_object_layout_t get_layout() { return head.layout; }
+ ceph_object_layout get_layout() { return head.layout; }
epoch_t get_map_epoch() { return head.osdmap_epoch; }
eversion_t get_version() { return head.reassert_version; }
void set_attrset(map<string,bufferptr> &as) { attrset.swap(as); }
void set_peer_stat(const osd_peer_stat_t& stat) { head.peer_stat = stat; }
- const ceph_osd_peer_stat_t& get_peer_stat() { return head.peer_stat; }
+ const ceph_osd_peer_stat& get_peer_stat() { return head.peer_stat; }
void inc_shed_count() { head.shed_count++; }
int get_shed_count() { return head.shed_count; }
MOSDOp(entity_inst_t asker, int inc, long tid,
- object_t oid, ceph_object_layout_t ol, epoch_t mapepoch, int op) :
+ object_t oid, ceph_object_layout ol, epoch_t mapepoch, int op) :
Message(CEPH_MSG_OSD_OP) {
memset(&head, 0, sizeof(head));
head.client_inst.name = asker.name.v;
}
MOSDOp() {}
- void set_layout(const ceph_object_layout_t& l) { head.layout = l; }
+ void set_layout(const ceph_object_layout& l) { head.layout = l; }
void set_length(off_t l) { head.length = l; }
void set_offset(off_t o) { head.offset = o; }
class MonMap {
public:
epoch_t epoch; // what epoch/version of the monmap
- ceph_fsid_t fsid;
+ ceph_fsid fsid;
vector<entity_inst_t> mon_inst;
int last_mon; // last mon i talked to
// is this okay?
assert(superblock.current_epoch == 2);
- ceph_fsid_t nullfsid;
+ ceph_fsid nullfsid;
memset(&nullfsid, 0, sizeof(nullfsid));
if (memcmp(&nullfsid, &superblock.fsid, sizeof(nullfsid)) != 0) {
derr(0) << "will not mkfs, my superblock fsid is not zeroed" << dendl;
public:
class Incremental {
public:
- ceph_fsid_t fsid;
+ ceph_fsid fsid;
epoch_t epoch; // new epoch; we are a diff from epoch-1 to epoch
epoch_t mon_epoch; // monitor epoch (election iteration)
utime_t ctime;
};
private:
- ceph_fsid_t fsid;
+ ceph_fsid fsid;
epoch_t epoch; // what epoch of the osd cluster descriptor is this
epoch_t mon_epoch; // monitor epoch (election iteration)
utime_t ctime, mtime; // epoch start time
}
// map info
- ceph_fsid_t& get_fsid() { return fsid; }
- void set_fsid(ceph_fsid_t& f) { fsid = f; }
+ ceph_fsid& get_fsid() { return fsid; }
+ void set_fsid(ceph_fsid& f) { fsid = f; }
epoch_t get_epoch() const { return epoch; }
void inc_epoch() { epoch++; }
/**** mapping facilities ****/
// oid -> pg
- ceph_object_layout_t file_to_object_layout(object_t oid, FileLayout& layout) {
+ ceph_object_layout file_to_object_layout(object_t oid, FileLayout& layout) {
return make_object_layout(oid, layout.fl_pg_type, layout.fl_pg_size, layout.fl_pg_preferred, layout.fl_object_stripe_unit);
}
- ceph_object_layout_t make_object_layout(object_t oid, int pg_type, int pg_size, int preferred=-1, int object_stripe_unit = 0) {
+ ceph_object_layout make_object_layout(object_t oid, int pg_type, int pg_size, int preferred=-1, int object_stripe_unit = 0) {
int num = preferred >= 0 ? localized_pg_num:pg_num;
int num_mask = preferred >= 0 ? localized_pg_num_mask:pg_num_mask;
// construct object layout
pg_t pgid = pg_t(pg_type, pg_size, ps, preferred);
- ceph_object_layout_t layout;
+ ceph_object_layout layout;
layout.pgid = pgid.u;
layout.stripe_unit = object_stripe_unit;
return layout;
// a write will do something like
object_t oid = op->get_oid(); // logical object
pg_t pg = op->get_pg();
- ceph_object_layout_t layout = op->get_layout();
+ ceph_object_layout layout = op->get_layout();
bufferlist data = op->get_data();
off_t off = op->get_offset();
off_t left = op->get_length();
balancing_reads.count(oid) == 0) {
dout(-10) << "preprocess_op balance-reads on " << oid << dendl;
balancing_reads.insert(oid);
- ceph_object_layout_t layout;
+ ceph_object_layout layout;
layout.pgid = info.pgid.u;
layout.stripe_unit = 0;
MOSDOp *pop = new MOSDOp(osd->messenger->get_myinst(), 0, osd->get_tid(),
!unbalancing_reads.count(oid) == 0) {
dout(-10) << "preprocess_op unbalance-reads on " << oid << dendl;
unbalancing_reads.insert(oid);
- ceph_object_layout_t layout;
+ ceph_object_layout layout;
layout.pgid = info.pgid.u;
layout.stripe_unit = 0;
MOSDOp *pop = new MOSDOp(osd->messenger->get_myinst(), 0, osd->get_tid(),
dout(-10) << "preprocess_op unbalancing-reads on " << op->get_oid() << dendl;
unbalancing_reads.insert(op->get_oid());
- ceph_object_layout_t layout;
+ ceph_object_layout layout;
layout.pgid = info.pgid.u;
layout.stripe_unit = 0;
MOSDOp *pop = new MOSDOp(osd->messenger->get_myinst(), 0, osd->get_tid(),
assert(sizeof(u.pg) == sizeof(u.pg64));
}
pg_t(uint64_t v) { u.pg64 = v; }
- pg_t(const ceph_pg_t& cpg) {
+ pg_t(const ceph_pg& cpg) {
u = cpg;
}
-inline ostream& operator<<(ostream& out, const ceph_object_layout_t &ol)
+inline ostream& operator<<(ostream& out, const ceph_object_layout &ol)
{
out << "pg" << ol.pgid;
if (ol.stripe_unit)
eversion_t(epoch_t e, version_t v) : epoch(e), version(v) {}
eversion_t(const ceph_eversion& ce) : epoch(ce.epoch), version(ce.version) {}
- operator ceph_eversion_t() {
- ceph_eversion_t c;
+ operator ceph_eversion() {
+ ceph_eversion c;
c.epoch = epoch;
c.version = version;
return c;
off_t start; // in object
size_t length; // in object
- ceph_object_layout_t layout; // object layout (pgid, etc.)
+ ceph_object_layout layout; // object layout (pgid, etc.)
map<size_t, size_t> buffer_extents; // off -> len. extents in buffer being mapped (may be fragmented bc of striping!)
public:
const static uint64_t MAGIC = 0xeb0f505dULL;
uint64_t magic;
- ceph_fsid_t fsid;
+ ceph_fsid fsid;
int32_t whoami; // my role in this fs.
epoch_t current_epoch; // most recent epoch
epoch_t oldest_map, newest_map; // oldest/newest maps we have.
object_t oid; // this _always_ is oid.rev=0
inodeno_t ino;
objectrev_t rev; // last rev we're written
- ceph_object_layout_t layout;
+ ceph_object_layout layout;
public:
map<off_t, BufferHead*> data;
int rdlock_ref; // how many ppl want or are using a READ lock
public:
- Object(ObjectCacher *_oc, object_t o, inodeno_t i, ceph_object_layout_t& l) :
+ Object(ObjectCacher *_oc, object_t o, inodeno_t i, ceph_object_layout& l) :
oc(_oc),
oid(o), ino(i), layout(l),
last_write_tid(0), last_ack_tid(0), last_commit_tid(0),
object_t get_oid() { return oid; }
inodeno_t get_ino() { return ino; }
- ceph_object_layout_t& get_layout() { return layout; }
- void set_layout(ceph_object_layout_t& l) { layout = l; }
+ ceph_object_layout& get_layout() { return layout; }
+ void set_layout(ceph_object_layout& l) { layout = l; }
bool can_close() {
return data.empty() && lock_state == LOCK_NONE &&
// objects
- Object *get_object(object_t oid, inodeno_t ino, ceph_object_layout_t &l) {
+ Object *get_object(object_t oid, inodeno_t ino, ceph_object_layout &l) {
// have it?
if (objects.count(oid))
return objects[oid];
// stat -----------------------------------
-tid_t Objecter::stat(object_t oid, off_t *size, ceph_object_layout_t ol, Context *onfinish)
+tid_t Objecter::stat(object_t oid, off_t *size, ceph_object_layout ol, Context *onfinish)
{
OSDStat *st = new OSDStat(size);
st->extents.push_back(ObjectExtent(oid, 0, 0));
// read -----------------------------------
-tid_t Objecter::read(object_t oid, off_t off, size_t len, ceph_object_layout_t ol, bufferlist *bl,
+tid_t Objecter::read(object_t oid, off_t off, size_t len, ceph_object_layout ol, bufferlist *bl,
Context *onfinish)
{
OSDRead *rd = new OSDRead(bl);
// write ------------------------------------
-tid_t Objecter::write(object_t oid, off_t off, size_t len, ceph_object_layout_t ol, bufferlist &bl,
+tid_t Objecter::write(object_t oid, off_t off, size_t len, ceph_object_layout ol, bufferlist &bl,
Context *onack, Context *oncommit)
{
OSDWrite *wr = new OSDWrite(bl);
// zero
-tid_t Objecter::zero(object_t oid, off_t off, size_t len, ceph_object_layout_t ol,
+tid_t Objecter::zero(object_t oid, off_t off, size_t len, ceph_object_layout ol,
Context *onack, Context *oncommit)
{
OSDModify *z = new OSDModify(CEPH_OSD_OP_ZERO);
// lock ops
-tid_t Objecter::lock(int op, object_t oid, ceph_object_layout_t ol,
+tid_t Objecter::lock(int op, object_t oid, ceph_object_layout ol,
Context *onack, Context *oncommit)
{
OSDModify *l = new OSDModify(op);
// med level
tid_t readx(OSDRead *read, Context *onfinish);
tid_t modifyx(OSDModify *wr, Context *onack, Context *oncommit);
- //tid_t lockx(OSDLock *l, Context *onack, Context *oncommit);
// even lazier
- tid_t read(object_t oid, off_t off, size_t len, ceph_object_layout_t ol, bufferlist *bl,
+ tid_t read(object_t oid, off_t off, size_t len, ceph_object_layout ol, bufferlist *bl,
Context *onfinish);
- tid_t write(object_t oid, off_t off, size_t len, ceph_object_layout_t ol, bufferlist &bl,
+ tid_t write(object_t oid, off_t off, size_t len, ceph_object_layout ol, bufferlist &bl,
Context *onack, Context *oncommit);
- tid_t zero(object_t oid, off_t off, size_t len, ceph_object_layout_t ol,
+ tid_t zero(object_t oid, off_t off, size_t len, ceph_object_layout ol,
Context *onack, Context *oncommit);
- tid_t stat(object_t oid, off_t *size, ceph_object_layout_t ol, Context *onfinish);
+ tid_t stat(object_t oid, off_t *size, ceph_object_layout ol, Context *onfinish);
- tid_t lock(int op, object_t oid, ceph_object_layout_t ol, Context *onack, Context *oncommit);
+ tid_t lock(int op, object_t oid, ceph_object_layout ol, Context *onack, Context *oncommit);
void ms_handle_failure(Message *m, entity_name_t dest, const entity_inst_t& inst);