[ceph.git] / ceph / src / mds / Mutation.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software 
 * Foundation.  See file COPYING.
 * 
 */

#include "Mutation.h"
#include "ScatterLock.h"
#include "CDir.h"

#include "messages/MClientRequest.h"
#include "messages/MMDSSlaveRequest.h"


// MutationImpl

void MutationImpl::pin(MDSCacheObject *o)
{
  if (pins.count(o) == 0) {
    o->get(MDSCacheObject::PIN_REQUEST);
    pins.insert(o);
  }      
}

void MutationImpl::unpin(MDSCacheObject *o)
{
  assert(pins.count(o));
  o->put(MDSCacheObject::PIN_REQUEST);
  pins.erase(o);
}

void MutationImpl::set_stickydirs(CInode *in)
{
  if (stickydirs.count(in) == 0) {
    in->get_stickydirs();
    stickydirs.insert(in);
  }
}

void MutationImpl::drop_pins()
{
  for (set<MDSCacheObject*>::iterator it = pins.begin();
       it != pins.end();
       ++it) 
    (*it)->put(MDSCacheObject::PIN_REQUEST);
  pins.clear();
}

void MutationImpl::start_locking(SimpleLock *lock, int target)
{
  assert(locking == NULL);
  pin(lock->get_parent());
  locking = lock;
  locking_target_mds = target;
}

void MutationImpl::finish_locking(SimpleLock *lock)
{
  assert(locking == lock);
  locking = NULL;
  locking_target_mds = -1;
}


// auth pins
bool MutationImpl::is_auth_pinned(MDSCacheObject *object) const
{ 
  return auth_pins.count(object) || remote_auth_pins.count(object); 
}

void MutationImpl::auth_pin(MDSCacheObject *object)
{
  if (!is_auth_pinned(object)) {
    object->auth_pin(this);
    auth_pins.insert(object);
  }
}

void MutationImpl::auth_unpin(MDSCacheObject *object)
{
  assert(auth_pins.count(object));
  object->auth_unpin(this);
  auth_pins.erase(object);
}

void MutationImpl::drop_local_auth_pins()
{
  for (set<MDSCacheObject*>::iterator it = auth_pins.begin();
       it != auth_pins.end();
       ++it) {
    assert((*it)->is_auth());
    (*it)->auth_unpin(this);
  }
  auth_pins.clear();
}

void MutationImpl::add_projected_inode(CInode *in)
{
  projected_inodes.push_back(in);
}

void MutationImpl::pop_and_dirty_projected_inodes()
{
  while (!projected_inodes.empty()) {
    CInode *in = projected_inodes.front();
    projected_inodes.pop_front();
    in->pop_and_dirty_projected_inode(ls);
  }
}

void MutationImpl::add_projected_fnode(CDir *dir)
{
  projected_fnodes.push_back(dir);
}

void MutationImpl::pop_and_dirty_projected_fnodes()
{
  while (!projected_fnodes.empty()) {
    CDir *dir = projected_fnodes.front();
    projected_fnodes.pop_front();
    dir->pop_and_dirty_projected_fnode(ls);
  }
}

void MutationImpl::add_updated_lock(ScatterLock *lock)
{
  updated_locks.push_back(lock);
}

void MutationImpl::add_cow_inode(CInode *in)
{
  pin(in);
  dirty_cow_inodes.push_back(in);
}

void MutationImpl::add_cow_dentry(CDentry *dn)
{
  pin(dn);
  dirty_cow_dentries.push_back(pair<CDentry*,version_t>(dn, dn->get_projected_version()));
}

void MutationImpl::apply()
{
  pop_and_dirty_projected_inodes();
  pop_and_dirty_projected_fnodes();
  
  for (list<CInode*>::iterator p = dirty_cow_inodes.begin();
       p != dirty_cow_inodes.end();
       ++p) 
    (*p)->_mark_dirty(ls);
  for (list<pair<CDentry*,version_t> >::iterator p = dirty_cow_dentries.begin();
       p != dirty_cow_dentries.end();
       ++p)
    p->first->mark_dirty(p->second, ls);
  
  for (list<ScatterLock*>::iterator p = updated_locks.begin();
       p != updated_locks.end();
       ++p)
    (*p)->mark_dirty();
}

void MutationImpl::cleanup()
{
  drop_local_auth_pins();
  drop_pins();
}

void MutationImpl::_dump_op_descriptor_unlocked(ostream& stream) const
{
  stream << "Mutation";
}

// MDRequestImpl

MDRequestImpl::~MDRequestImpl()
{
  if (client_request)
    client_request->put();
  if (slave_request)
    slave_request->put();
  delete _more;
}

MDRequestImpl::More* MDRequestImpl::more()
{ 
  if (!_more)
    _more = new More();
  return _more;
}

bool MDRequestImpl::has_more() const
{
  return _more != nullptr;
}

bool MDRequestImpl::has_witnesses()
{
  return (_more != nullptr) && (!_more->witnessed.empty());
}

bool MDRequestImpl::slave_did_prepare()
{
  return has_more() && more()->slave_commit;
}

bool MDRequestImpl::slave_rolling_back()
{
  return has_more() && more()->slave_rolling_back;
}

bool MDRequestImpl::did_ino_allocation() const
{
  return alloc_ino || used_prealloc_ino || prealloc_inos.size();
}      

bool MDRequestImpl::freeze_auth_pin(CInode *inode)
{
  assert(!more()->rename_inode || more()->rename_inode == inode);
  more()->rename_inode = inode;
  more()->is_freeze_authpin = true;
  auth_pin(inode);
  if (!inode->freeze_inode(1)) {
    return false;
  }
  inode->freeze_auth_pin();
  inode->unfreeze_inode();
  return true;
}

void MDRequestImpl::unfreeze_auth_pin(bool clear_inode)
{
  assert(more()->is_freeze_authpin);
  CInode *inode = more()->rename_inode;
  if (inode->is_frozen_auth_pin())
    inode->unfreeze_auth_pin();
  else
    inode->unfreeze_inode();
  more()->is_freeze_authpin = false;
  if (clear_inode)
    more()->rename_inode = NULL;
}

void MDRequestImpl::set_remote_frozen_auth_pin(CInode *inode)
{
  more()->rename_inode = inode;
  more()->is_remote_frozen_authpin = true;
}

void MDRequestImpl::set_ambiguous_auth(CInode *inode)
{
  assert(!more()->rename_inode || more()->rename_inode == inode);
  assert(!more()->is_ambiguous_auth);

  inode->set_ambiguous_auth();
  more()->rename_inode = inode;
  more()->is_ambiguous_auth = true;
}

void MDRequestImpl::clear_ambiguous_auth()
{
  CInode *inode = more()->rename_inode;
  assert(inode && more()->is_ambiguous_auth);
  inode->clear_ambiguous_auth();
  more()->is_ambiguous_auth = false;
}

bool MDRequestImpl::can_auth_pin(MDSCacheObject *object)
{
  return object->can_auth_pin() ||
         (is_auth_pinned(object) && has_more() &&
	  more()->is_freeze_authpin &&
	  more()->rename_inode == object);
}

void MDRequestImpl::drop_local_auth_pins()
{
  if (has_more() && more()->is_freeze_authpin)
    unfreeze_auth_pin(true);
  MutationImpl::drop_local_auth_pins();
}

const filepath& MDRequestImpl::get_filepath()
{
  if (client_request)
    return client_request->get_filepath();
  return more()->filepath1;
}

const filepath& MDRequestImpl::get_filepath2()
{
  if (client_request)
    return client_request->get_filepath2();
  return more()->filepath2;
}

void MDRequestImpl::set_filepath(const filepath& fp)
{
  assert(!client_request);
  more()->filepath1 = fp;
}

void MDRequestImpl::set_filepath2(const filepath& fp)
{
  assert(!client_request);
  more()->filepath2 = fp;
}

bool MDRequestImpl::is_queued_for_replay() const
{
  return client_request ? client_request->is_queued_for_replay() : false;
}

void MDRequestImpl::print(ostream &out) const
{
  out << "request(" << reqid;
  //if (request) out << " " << *request;
  if (is_slave()) out << " slave_to mds." << slave_to_mds;
  if (client_request) out << " cr=" << client_request;
  if (slave_request) out << " sr=" << slave_request;
  out << ")";
}

void MDRequestImpl::dump(Formatter *f) const
{
  _dump(f);
}

void MDRequestImpl::_dump(Formatter *f) const
{
  f->dump_string("flag_point", state_string());
  f->dump_stream("reqid") << reqid;
  {
    if (client_request) {
      f->dump_string("op_type", "client_request");
      f->open_object_section("client_info");
      f->dump_stream("client") << client_request->get_orig_source();
      f->dump_int("tid", client_request->get_tid());
      f->close_section(); // client_info
    } else if (is_slave() && slave_request) { // replies go to an existing mdr
      f->dump_string("op_type", "slave_request");
      f->open_object_section("master_info");
      f->dump_stream("master") << slave_request->get_orig_source();
      f->close_section(); // master_info

      f->open_object_section("request_info");
      f->dump_int("attempt", slave_request->get_attempt());
      f->dump_string("op_type",
                     slave_request->get_opname(slave_request->get_op()));
      f->dump_int("lock_type", slave_request->get_lock_type());
      f->dump_stream("object_info") << slave_request->get_object_info();
      f->dump_stream("srcdnpath") << slave_request->srcdnpath;
      f->dump_stream("destdnpath") << slave_request->destdnpath;
      f->dump_stream("witnesses") << slave_request->witnesses;
      f->dump_bool("has_inode_export",
                   slave_request->inode_export.length() != 0);
      f->dump_int("inode_export_v", slave_request->inode_export_v);
      f->dump_bool("has_srci_replica",
                   slave_request->srci_replica.length() != 0);
      f->dump_stream("op_stamp") << slave_request->op_stamp;
      f->close_section(); // request_info
    }
    else if (internal_op != -1) { // internal request
      f->dump_string("op_type", "internal_op");
      f->dump_int("internal_op", internal_op);
      f->dump_string("op_name", ceph_mds_op_name(internal_op));
    }
    else {
      f->dump_string("op_type", "no_available_op_found");
    }
  }
  {
    f->open_array_section("events");
    Mutex::Locker l(lock);
    for (auto& i : events) {
      f->dump_object("event", i);
    }
    f->close_section(); // events
  }
}

void MDRequestImpl::_dump_op_descriptor_unlocked(ostream& stream) const
{
  if (client_request) {
    client_request->print(stream);
  } else if (slave_request) {
    slave_request->print(stream);
  } else if (internal_op >= 0) {
    stream << "internal op " << ceph_mds_op_name(internal_op) << ":" << reqid;
  } else {
    // drat, it's triggered by a slave request, but we don't have a message
    // FIXME
    stream << "rejoin:" << reqid;
  }
}
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3	/*
	4	* Ceph - scalable distributed file system
	5	*
	6	* Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
	7	*
	8	* This is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License version 2.1, as published by the Free Software
	11	* Foundation. See file COPYING.
	12	*
	13	*/
	14
	15	#include "Mutation.h"
	16	#include "ScatterLock.h"
	17	#include "CDir.h"
	18
	19	#include "messages/MClientRequest.h"
	20	#include "messages/MMDSSlaveRequest.h"
	21
	22
	23	// MutationImpl
	24
	25	void MutationImpl::pin(MDSCacheObject *o)
	26	{
	27	if (pins.count(o) == 0) {
	28	o->get(MDSCacheObject::PIN_REQUEST);
	29	pins.insert(o);
	30	}
	31	}
	32
	33	void MutationImpl::unpin(MDSCacheObject *o)
	34	{
	35	assert(pins.count(o));
	36	o->put(MDSCacheObject::PIN_REQUEST);
	37	pins.erase(o);
	38	}
	39
	40	void MutationImpl::set_stickydirs(CInode *in)
	41	{
	42	if (stickydirs.count(in) == 0) {
	43	in->get_stickydirs();
	44	stickydirs.insert(in);
	45	}
	46	}
	47
	48	void MutationImpl::drop_pins()
	49	{
	50	for (set<MDSCacheObject*>::iterator it = pins.begin();
	51	it != pins.end();
	52	++it)
	53	(*it)->put(MDSCacheObject::PIN_REQUEST);
	54	pins.clear();
	55	}
	56
	57	void MutationImpl::start_locking(SimpleLock *lock, int target)
	58	{
	59	assert(locking == NULL);
	60	pin(lock->get_parent());
	61	locking = lock;
	62	locking_target_mds = target;
	63	}
	64
65	void MutationImpl::finish_locking(SimpleLock *lock)
66	{
67	assert(locking == lock);
68	locking = NULL;
69	locking_target_mds = -1;
70	}
71
72
73	// auth pins
74	bool MutationImpl::is_auth_pinned(MDSCacheObject *object) const
75	{
76	return auth_pins.count(object) \|\| remote_auth_pins.count(object);
77	}
78
79	void MutationImpl::auth_pin(MDSCacheObject *object)
80	{
81	if (!is_auth_pinned(object)) {
82	object->auth_pin(this);
83	auth_pins.insert(object);
84	}
85	}
86
87	void MutationImpl::auth_unpin(MDSCacheObject *object)
88	{
89	assert(auth_pins.count(object));
90	object->auth_unpin(this);
91	auth_pins.erase(object);
92	}
93
94	void MutationImpl::drop_local_auth_pins()
95	{
96	for (set<MDSCacheObject*>::iterator it = auth_pins.begin();
97	it != auth_pins.end();
98	++it) {
99	assert((*it)->is_auth());
100	(*it)->auth_unpin(this);
101	}
102	auth_pins.clear();
103	}
104
105	void MutationImpl::add_projected_inode(CInode *in)
106	{
107	projected_inodes.push_back(in);
108	}
109
110	void MutationImpl::pop_and_dirty_projected_inodes()
111	{
112	while (!projected_inodes.empty()) {
113	CInode *in = projected_inodes.front();
114	projected_inodes.pop_front();
115	in->pop_and_dirty_projected_inode(ls);
116	}
117	}
118
119	void MutationImpl::add_projected_fnode(CDir *dir)
120	{
121	projected_fnodes.push_back(dir);
122	}
123
124	void MutationImpl::pop_and_dirty_projected_fnodes()
125	{
126	while (!projected_fnodes.empty()) {
127	CDir *dir = projected_fnodes.front();
128	projected_fnodes.pop_front();
129	dir->pop_and_dirty_projected_fnode(ls);
130	}
131	}
132
133	void MutationImpl::add_updated_lock(ScatterLock *lock)
134	{
135	updated_locks.push_back(lock);
136	}
137
138	void MutationImpl::add_cow_inode(CInode *in)
139	{
140	pin(in);
141	dirty_cow_inodes.push_back(in);
142	}
143
144	void MutationImpl::add_cow_dentry(CDentry *dn)
145	{
146	pin(dn);
147	dirty_cow_dentries.push_back(pair<CDentry*,version_t>(dn, dn->get_projected_version()));
148	}
149
150	void MutationImpl::apply()
151	{
152	pop_and_dirty_projected_inodes();
153	pop_and_dirty_projected_fnodes();
154
155	for (list<CInode*>::iterator p = dirty_cow_inodes.begin();
156	p != dirty_cow_inodes.end();
157	++p)
158	(*p)->_mark_dirty(ls);
159	for (list<pair<CDentry*,version_t> >::iterator p = dirty_cow_dentries.begin();
160	p != dirty_cow_dentries.end();
161	++p)
162	p->first->mark_dirty(p->second, ls);
163
164	for (list<ScatterLock*>::iterator p = updated_locks.begin();
165	p != updated_locks.end();
166	++p)
167	(*p)->mark_dirty();
168	}
169
170	void MutationImpl::cleanup()
171	{
172	drop_local_auth_pins();
173	drop_pins();
174	}
175
176	void MutationImpl::_dump_op_descriptor_unlocked(ostream& stream) const
177	{
178	stream << "Mutation";
179	}
180
181	// MDRequestImpl
182
183	MDRequestImpl::~MDRequestImpl()
184	{
185	if (client_request)
186	client_request->put();
187	if (slave_request)
188	slave_request->put();
189	delete _more;
190	}
191
192	MDRequestImpl::More* MDRequestImpl::more()
193	{
194	if (!_more)
195	_more = new More();
196	return _more;
197	}
198
199	bool MDRequestImpl::has_more() const
200	{
201	return _more != nullptr;
202	}
203
204	bool MDRequestImpl::has_witnesses()
205	{
206	return (_more != nullptr) && (!_more->witnessed.empty());
207	}
208
209	bool MDRequestImpl::slave_did_prepare()
210	{
211	return has_more() && more()->slave_commit;
212	}
213
214	bool MDRequestImpl::slave_rolling_back()
215	{
216	return has_more() && more()->slave_rolling_back;
217	}
218
219	bool MDRequestImpl::did_ino_allocation() const
220	{
221	return alloc_ino \|\| used_prealloc_ino \|\| prealloc_inos.size();
222	}
223
224	bool MDRequestImpl::freeze_auth_pin(CInode *inode)
225	{
226	assert(!more()->rename_inode \|\| more()->rename_inode == inode);
227	more()->rename_inode = inode;
228	more()->is_freeze_authpin = true;
229	auth_pin(inode);
230	if (!inode->freeze_inode(1)) {
231	return false;
232	}
233	inode->freeze_auth_pin();
234	inode->unfreeze_inode();
235	return true;
236	}
237
238	void MDRequestImpl::unfreeze_auth_pin(bool clear_inode)
239	{
240	assert(more()->is_freeze_authpin);
241	CInode *inode = more()->rename_inode;
242	if (inode->is_frozen_auth_pin())
243	inode->unfreeze_auth_pin();
244	else
245	inode->unfreeze_inode();
246	more()->is_freeze_authpin = false;
247	if (clear_inode)
248	more()->rename_inode = NULL;
249	}
250
251	void MDRequestImpl::set_remote_frozen_auth_pin(CInode *inode)
252	{
253	more()->rename_inode = inode;
254	more()->is_remote_frozen_authpin = true;
255	}
256
257	void MDRequestImpl::set_ambiguous_auth(CInode *inode)
258	{
259	assert(!more()->rename_inode \|\| more()->rename_inode == inode);
260	assert(!more()->is_ambiguous_auth);
261
262	inode->set_ambiguous_auth();
263	more()->rename_inode = inode;
264	more()->is_ambiguous_auth = true;
265	}
266
267	void MDRequestImpl::clear_ambiguous_auth()
268	{
269	CInode *inode = more()->rename_inode;
270	assert(inode && more()->is_ambiguous_auth);
271	inode->clear_ambiguous_auth();
272	more()->is_ambiguous_auth = false;
273	}
274
275	bool MDRequestImpl::can_auth_pin(MDSCacheObject *object)
276	{
277	return object->can_auth_pin() \|\|
278	(is_auth_pinned(object) && has_more() &&
279	more()->is_freeze_authpin &&
280	more()->rename_inode == object);
281	}
282
283	void MDRequestImpl::drop_local_auth_pins()
284	{
285	if (has_more() && more()->is_freeze_authpin)
286	unfreeze_auth_pin(true);
287	MutationImpl::drop_local_auth_pins();
288	}
289
290	const filepath& MDRequestImpl::get_filepath()
291	{
292	if (client_request)
293	return client_request->get_filepath();
294	return more()->filepath1;
295	}
296
297	const filepath& MDRequestImpl::get_filepath2()
298	{
299	if (client_request)
300	return client_request->get_filepath2();
301	return more()->filepath2;
302	}
303
304	void MDRequestImpl::set_filepath(const filepath& fp)
305	{
306	assert(!client_request);
307	more()->filepath1 = fp;
308	}
309
310	void MDRequestImpl::set_filepath2(const filepath& fp)
311	{
312	assert(!client_request);
313	more()->filepath2 = fp;
314	}
315
b32b8144	316	bool MDRequestImpl::is_queued_for_replay() const
7c673cae	317	{
b32b8144	318	return client_request ? client_request->is_queued_for_replay() : false;
7c673cae FG	319	}
	320
	321	void MDRequestImpl::print(ostream &out) const
	322	{
	323	out << "request(" << reqid;
	324	//if (request) out << " " << *request;
	325	if (is_slave()) out << " slave_to mds." << slave_to_mds;
	326	if (client_request) out << " cr=" << client_request;
	327	if (slave_request) out << " sr=" << slave_request;
	328	out << ")";
	329	}
	330
	331	void MDRequestImpl::dump(Formatter *f) const
	332	{
	333	_dump(f);
	334	}
	335
	336	void MDRequestImpl::_dump(Formatter *f) const
	337	{
	338	f->dump_string("flag_point", state_string());
	339	f->dump_stream("reqid") << reqid;
	340	{
	341	if (client_request) {
	342	f->dump_string("op_type", "client_request");
	343	f->open_object_section("client_info");
	344	f->dump_stream("client") << client_request->get_orig_source();
	345	f->dump_int("tid", client_request->get_tid());
	346	f->close_section(); // client_info
	347	} else if (is_slave() && slave_request) { // replies go to an existing mdr
	348	f->dump_string("op_type", "slave_request");
	349	f->open_object_section("master_info");
	350	f->dump_stream("master") << slave_request->get_orig_source();
	351	f->close_section(); // master_info
	352
	353	f->open_object_section("request_info");
	354	f->dump_int("attempt", slave_request->get_attempt());
	355	f->dump_string("op_type",
	356	slave_request->get_opname(slave_request->get_op()));
	357	f->dump_int("lock_type", slave_request->get_lock_type());
	358	f->dump_stream("object_info") << slave_request->get_object_info();
	359	f->dump_stream("srcdnpath") << slave_request->srcdnpath;
	360	f->dump_stream("destdnpath") << slave_request->destdnpath;
	361	f->dump_stream("witnesses") << slave_request->witnesses;
	362	f->dump_bool("has_inode_export",
	363	slave_request->inode_export.length() != 0);
	364	f->dump_int("inode_export_v", slave_request->inode_export_v);
	365	f->dump_bool("has_srci_replica",
	366	slave_request->srci_replica.length() != 0);
	367	f->dump_stream("op_stamp") << slave_request->op_stamp;
	368	f->close_section(); // request_info
	369	}
	370	else if (internal_op != -1) { // internal request
	371	f->dump_string("op_type", "internal_op");
	372	f->dump_int("internal_op", internal_op);
	373	f->dump_string("op_name", ceph_mds_op_name(internal_op));
	374	}
	375	else {
	376	f->dump_string("op_type", "no_available_op_found");
	377	}
	378	}
	379	{
	380	f->open_array_section("events");
	381	Mutex::Locker l(lock);
	382	for (auto& i : events) {
383	f->dump_object("event", i);
384	}
385	f->close_section(); // events
386	}
387	}
388
389	void MDRequestImpl::_dump_op_descriptor_unlocked(ostream& stream) const
390	{
391	if (client_request) {
392	client_request->print(stream);
393	} else if (slave_request) {
394	slave_request->print(stream);
395	} else if (internal_op >= 0) {
396	stream << "internal op " << ceph_mds_op_name(internal_op) << ":" << reqid;
397	} else {
398	// drat, it's triggered by a slave request, but we don't have a message
399	// FIXME
400	stream << "rejoin:" << reqid;
401	}
402	}