Ceph » CephFS

<< truncate_size << dendl;

in->truncate_size = truncate_size;

in->oset.truncate_size = truncate_size;

} else {

ldout(cct, 0) << "Hmmm, truncate_seq && truncate_size changed on non-file inode!" << dendl;

}

// invalidate our userspace inode cache

if (cct->_conf->client_oc) {

vector<ObjectExtent> ls;

objectcacher->discard_set(&in->oset, ls);

}

Inode *in = f->inode;

vector<ObjectExtent> extents;

assert(extents.size() == 1);

pg_t pg = osdmap->object_locator_to_pg(extents[0].oid, extents[0].oloc);

// which object?

vector<ObjectExtent> extents;

assert(extents.size() == 1);

// now we have the object and its 'layout'

Inode *in = f->inode;

// map to a list of extents

ldout(cct, 3) << "enumerate_layout(" << fd << ", " << length << ", " << offset << ") = 0" << dendl;

return 0;

snap_lock.get_read();

ObjectCacher::OSDRead *rd = object_cacher->prepare_read(snap_id, bl, 0);

snap_lock.put_read();

extent.oloc.pool = data_ctx.get_id();

extent.buffer_extents.push_back(make_pair(0, len));

rd->extents.push_back(extent);

ObjectCacher::OSDWrite *wr = object_cacher->prepare_write(snapc, bl,

utime_t(), 0);

snap_lock.put_read();

extent.oloc.pool = data_ctx.get_id();

extent.buffer_extents.push_back(make_pair(0, len));

wr->extents.push_back(extent);

if (delete_off > newsize) {

vector<ObjectExtent> extents;

Striper::file_to_extents(ictx->cct, ictx->format_string, &ictx->layout,

for (vector<ObjectExtent>::iterator p = extents.begin();

p != extents.end(); ++p) {

// map to extents

map<object_t,vector<ObjectExtent> > object_extents;

Striper::file_to_extents(ictx->cct, ictx->format_string, &ictx->layout,

// get snap info for each object

for (map<object_t,vector<ObjectExtent> >::iterator p = object_extents.begin();

// map

vector<ObjectExtent> extents;

c->get();

c->init_time(ictx, AIO_TYPE_WRITE);

// map

vector<ObjectExtent> extents;

c->get();

c->init_time(ictx, AIO_TYPE_DISCARD);

return r;

Striper::file_to_extents(ictx->cct, ictx->format_string, &ictx->layout,

buffer_ofs += len;

}

uint64_t objectno;

uint64_t offset; // in object

uint64_t length; // in object

object_locator_t oloc; // object locator (pool etc)

vector<pair<uint64_t,uint64_t> > buffer_extents; // off -> len. extents in buffer being mapped (may be fragmented bc of striping!)

};

inline ostream& operator<<(ostream& out, const ObjectExtent &ex)

probe->known_size.clear();

probe->probing.clear();

Striper::file_to_extents(cct, probe->ino, &probe->layout,

for (vector<ObjectExtent>::iterator p = probe->probing.begin();

p != probe->probing.end();

Context *onfinish) {

assert(snap); // (until there is a non-NOSNAP write)

vector<ObjectExtent> extents;

objecter->sg_read(extents, snap, bl, flags, onfinish);

return 0;

}

Context *onfinish) {

assert(snap); // (until there is a non-NOSNAP write)

vector<ObjectExtent> extents;

objecter->sg_read_trunc(extents, snap, bl, flags,

truncate_size, truncate_seq, onfinish);

return 0;

Context *onack,

Context *oncommit) {

vector<ObjectExtent> extents;

objecter->sg_write(extents, snapc, bl, mtime, flags, onack, oncommit);

return 0;

}

Context *onack,

Context *oncommit) {

vector<ObjectExtent> extents;

objecter->sg_write_trunc(extents, snapc, bl, mtime, flags,

truncate_size, truncate_seq, onack, oncommit);

return 0;

Context *onack,

Context *oncommit) {

vector<ObjectExtent> extents;

if (extents.size() == 1) {

vector<OSDOp> ops(1);

ops[0].op.op = CEPH_OSD_OP_TRIMTRUNC;

Context *onack,

Context *oncommit) {

vector<ObjectExtent> extents;

if (extents.size() == 1) {

if (extents[0].offset == 0 && extents[0].length == layout->fl_object_size)

objecter->remove(extents[0].oid, extents[0].oloc,

/* private */

ObjectCacher::Object *ObjectCacher::get_object(sobject_t oid, ObjectSet *oset,

{

assert(lock.is_locked());

// have it?

}

// create it.

objects[l.pool][oid] = o;

ob_lru.lru_insert_top(o);

return o;

// go

writeback_handler.read(bh->ob->get_oid(), bh->ob->get_oloc(),

bh->start(), bh->length(), bh->ob->get_snap(),

onfinish);

++reads_outstanding;

}

tid_t tid = writeback_handler.write(bh->ob->get_oid(), bh->ob->get_oloc(),

bh->start(), bh->length(),

bh->snapc, bh->bl, bh->last_write,

oncommit);

ldout(cct, 20) << " tid " << tid << " on " << bh->ob->get_oid() << dendl;

// get Object cache

sobject_t soid(ex_it->oid, rd->snap);

touch_ob(o);

// does not exist and no hits?

++ex_it) {

// get object cache

sobject_t soid(ex_it->oid, CEPH_NOSNAP);

// map it all into a single bufferhead.

BufferHead *bh = o->map_write(wr);

flush_set_callback(flush_set_callback_arg, oset);

}

void ObjectCacher::verify_stats() const

{

assert(lock.is_locked());

ObjectSet *oset;

xlist<Object*>::item set_item;

object_locator_t oloc;

bool complete;

bool exists;

Object(const Object& other);

const Object& operator=(const Object& other);

ref(0),

oc(_oc),

complete(false), exists(true),

last_write_tid(0), last_commit_tid(0),

dirty_or_tx(0) {

}

Object *get_object(sobject_t oid, ObjectSet *oset,

void close_object(Object *ob);

// bh stats

// file functions

/*** async+caching (non-blocking) file interface ***/

int file_is_cached(ObjectSet *oset, ceph_file_layout *layout, snapid_t snapid,

loff_t offset, uint64_t len) {

vector<ObjectExtent> extents;

return is_cached(oset, extents, snapid);

}

int flags,

Context *onfinish) {

OSDRead *rd = prepare_read(snapid, bl, flags);

return readx(rd, oset, onfinish);

}

bufferlist& bl, utime_t mtime, int flags,

Mutex& wait_on_lock) {

OSDWrite *wr = prepare_write(snapc, bl, mtime, flags);

return writex(wr, oset, wait_on_lock, NULL);

}

bool file_flush(ObjectSet *oset, ceph_file_layout *layout, const SnapContext& snapc,

loff_t offset, uint64_t len, Context *onfinish) {

vector<ObjectExtent> extents;

return flush_set(oset, extents, onfinish);

}

};

uint64_t trunc_size, __u32 trunc_seq, Context *onfinish) {

if (extents.size() == 1) {

read_trunc(extents[0].oid, extents[0].oloc, extents[0].offset, extents[0].length,

} else {

C_GatherBuilder gather(cct);

vector<bufferlist> resultbl(extents.size());

int i=0;

for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); ++p) {

read_trunc(p->oid, p->oloc, p->offset, p->length,

}

gather.set_finisher(new C_SGRead(this, extents, resultbl, bl, onfinish));

gather.activate();

Context *onack, Context *oncommit) {

if (extents.size() == 1) {

write_trunc(extents[0].oid, extents[0].oloc, extents[0].offset, extents[0].length,

} else {

C_GatherBuilder gack(cct, onack);

C_GatherBuilder gcom(cct, oncommit);

bl.copy(bit->first, bit->second, cur);

assert(cur.length() == p->length);

write_trunc(p->oid, p->oloc, p->offset, p->length,

onack ? gack.new_sub():0,

oncommit ? gcom.new_sub():0);

}

void Striper::file_to_extents(CephContext *cct, const char *object_format,

ceph_file_layout *layout,

vector<ObjectExtent>& extents,

uint64_t buffer_offset)

{

map<object_t,vector<ObjectExtent> > object_extents;

assimilate_extents(object_extents, extents);

}

void Striper::file_to_extents(CephContext *cct, const char *object_format,

ceph_file_layout *layout,

map<object_t,vector<ObjectExtent> >& object_extents,

uint64_t buffer_offset)

{

ex->offset = x_offset;

ex->length = x_len;

ldout(cct, 20) << " added new " << *ex << dendl;

} else {

// add to extent

}

}

// StripedReadResult

*/

static void file_to_extents(CephContext *cct, const char *object_format,

ceph_file_layout *layout,

map<object_t, vector<ObjectExtent> >& extents,

uint64_t buffer_offset=0);

static void file_to_extents(CephContext *cct, const char *object_format,

ceph_file_layout *layout,

vector<ObjectExtent>& extents,

uint64_t buffer_offset=0);

static void file_to_extents(CephContext *cct, inodeno_t ino,

ceph_file_layout *layout,

vector<ObjectExtent>& extents) {

// generate prefix/format

char buf[32];

snprintf(buf, sizeof(buf), "%llx.%%08llx", (long long unsigned)ino);

}

static void assimilate_extents(map<object_t,vector<ObjectExtent> >& object_extents,

uint64_t objectno, uint64_t off, uint64_t len,

vector<pair<uint64_t, uint64_t> >& extents);

/*

* helper to assemble a striped result

*/

l.fl_stripe_count = 3;

vector<ObjectExtent> ex;

cout << "result " << ex << std::endl;

ASSERT_EQ(3u, ex.size());

}