# error "Unkown compiler"
#endif /* __GNUC__ */
-#define EXIT \
-do { \
- CDEBUG(D_TRACE, "Process leaving\n"); \
-} while(0)
-
extern int libcfs_debug_msg(struct libcfs_debug_msg_data *msgdata,
const char *format1, ...)
__attribute__ ((format (printf, 2, 3)));
ksocknal_free_tx (tx);
if (lnetmsg != NULL) /* KSOCK_MSG_NOOP go without lnetmsg */
lnet_finalize (ni, lnetmsg, rc);
-
- EXIT;
}
void
wake_up (&sched->kss_waitq);
}
spin_unlock_bh(&sched->kss_lock);
-
- EXIT;
}
/*
}
spin_unlock_bh(&sched->kss_lock);
-
- EXIT;
}
ksock_proto_t *
ksocknal_read_callback(conn);
read_unlock(&ksocknal_data.ksnd_global_lock);
-
- EXIT;
}
static void
ev->type = LNET_EVENT_UNLINK;
lnet_md_deconstruct(md, &ev->md);
lnet_md2handle(&ev->md_handle, md);
- EXIT;
}
/*
CDEBUG_LIMIT(debug_mask, "%s: Allocated %s-sequence "DRANGE"]\n",
seq->lcs_name, opcname, PRANGE(output));
- EXIT;
out_req:
ptlrpc_req_finished(req);
return rc;
lprocfs_remove(&seq->lcs_proc_dir);
seq->lcs_proc_dir = NULL;
}
- EXIT;
#endif /* LPROCFS */
}
}
seq->lcs_srv = NULL;
- EXIT;
}
EXPORT_SYMBOL(seq_client_fini);
CDEBUG(D_INFO, " Cache hits: "LPU64"%%\n", pct);
OBD_FREE_PTR(cache);
-
- EXIT;
}
/**
c_range->lsr_end == n_range->lsr_end)
fld_cache_entry_delete(cache, f_curr);
}
-
- EXIT;
}
/**
cache->fci_cache_size = 0;
fld_cache_shrink(cache);
write_unlock(&cache->fci_lock);
-
- EXIT;
}
/**
OBD_ALLOC_GFP(fldt, sizeof *fldt, GFP_ATOMIC);
if (!fldt) {
OBD_FREE_PTR(f_new);
- EXIT;
/* overlap is not allowed, so dont mess up list. */
return;
}
fld_cache_entry_add(cache, fldt, &f_new->fce_list);
/* no need to fixup */
- EXIT;
}
/**
lprocfs_remove(&fld->lcf_proc_dir);
fld->lcf_proc_dir = NULL;
}
- EXIT;
}
#else
static int fld_client_proc_init(struct lu_client_fld *fld)
rc = fld_client_proc_init(fld);
if (rc)
GOTO(out, rc);
- EXIT;
out:
if (rc)
fld_client_fini(fld);
fld_cache_fini(fld->lcf_cache);
fld->lcf_cache = NULL;
}
-
- EXIT;
}
EXPORT_SYMBOL(fld_client_fini);
if (prange == NULL)
GOTO(out_req, rc = -EFAULT);
*range = *prange;
- EXIT;
out_req:
ptlrpc_req_finished(req);
return rc;
len = lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens);
OBD_FREE(lcfg, len);
- EXIT;
return;
}
static inline void obd_ioctl_freedata(char *buf, int len)
{
OBD_FREE_LARGE(buf, len);
- EXIT;
return;
}
{
if (it != NULL && (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP ||
it->it_op == IT_LAYOUT))
- goto out;
+ return;
if (lck->rpcl_it == MDC_FAKE_RPCL_IT) { /* OBD_FAIL_MDC_RPCS_SEM */
mutex_lock(&lck->rpcl_mutex);
}
mutex_unlock(&lck->rpcl_mutex);
- out:
- EXIT;
}
static inline void mdc_update_max_ea_from_body(struct obd_export *exp,
obd->u.cli.cl_import = NULL;
}
up_write(&obd->u.cli.cl_sem);
-
- EXIT;
}
static inline int
OBD_COUNTER_INCREMENT(obd, getref);
OBP(obd, getref)(obd);
}
- EXIT;
}
static inline void obd_putref(struct obd_device *obd)
OBD_COUNTER_INCREMENT(obd, putref);
OBP(obd, putref)(obd);
}
- EXIT;
}
static inline int obd_init_export(struct obd_export *exp)
{
if (!obd) {
CERROR("NULL device\n");
- EXIT;
return;
}
if (obd->obd_set_up && OBP(obd, import_event)) {
OBD_COUNTER_INCREMENT(obd, import_event);
OBP(obd, import_event)(obd, imp, event);
}
- EXIT;
}
static inline int obd_llog_connect(struct obd_export *exp,
lock->cll_descr.cld_end == CL_PAGE_EOF)
cl_merge_lvb(env, inode);
}
- EXIT;
}
/*****************************************************************************
}
(*root)->in_color = INTERVAL_BLACK;
- EXIT;
}
struct interval_node *interval_insert(struct interval_node *node,
}
if (node)
node->in_color = INTERVAL_BLACK;
- EXIT;
}
/*
break;
node = node->in_parent;
}
- EXIT;
}
void interval_erase(struct interval_node *node,
color:
if (color == INTERVAL_BLACK)
interval_erase_color(child, parent, root);
- EXIT;
}
EXPORT_SYMBOL(interval_erase);
}
ldlm_lock_destroy_nolock(lock);
- EXIT;
}
/**
/* client side - set flag to prevent lock from being put on LRU list */
lock->l_flags |= LDLM_FL_CBPENDING;
unlock_res_and_lock(lock);
-
- EXIT;
}
/**
cfs_hash_putref(exp->exp_flock_hash);
exp->exp_flock_hash = NULL;
}
- EXIT;
}
EXPORT_SYMBOL(ldlm_destroy_flock_export);
ptlrpc_pinger_add_import(imp);
- EXIT;
-
if (rc) {
out_ldlm:
cli->cl_conn_count--;
ptlrpc_invalidate_import(imp);
- EXIT;
-
out_disconnect:
/* Use server style - class_disconnect should be always called for
* o_disconnect. */
struct obd_export *exp;
if (req->rq_no_reply) {
- EXIT;
return;
}
if (rs == NULL || !rs->rs_difficult) {
/* no notifiers */
target_send_reply_msg (req, rc, fail_id);
- EXIT;
return;
}
}
spin_unlock(&rs->rs_lock);
spin_unlock(&svcpt->scp_rep_lock);
- EXIT;
}
EXPORT_SYMBOL(target_send_reply);
lu_ref_fini(&lock->l_reference);
OBD_FREE_RCU(lock, sizeof(*lock), &lock->l_handle);
}
-
- EXIT;
}
EXPORT_SYMBOL(ldlm_lock_put);
spin_lock(&ns->ns_lock);
rc = ldlm_lock_remove_from_lru_nolock(lock);
spin_unlock(&ns->ns_lock);
- EXIT;
return rc;
}
spin_lock(&ns->ns_lock);
ldlm_lock_add_to_lru_nolock(lock);
spin_unlock(&ns->ns_lock);
- EXIT;
}
/**
if (lock->l_flags & LDLM_FL_NS_SRV) {
LASSERT(list_empty(&lock->l_lru));
- EXIT;
return;
}
ldlm_lock_add_to_lru_nolock(lock);
}
spin_unlock(&ns->ns_lock);
- EXIT;
}
/**
if (lock->l_flags & LDLM_FL_DESTROYED) {
LASSERT(list_empty(&lock->l_lru));
- EXIT;
return 0;
}
lock->l_flags |= LDLM_FL_DESTROYED;
if (lock->l_export && lock->l_completion_ast)
lock->l_completion_ast(lock, 0);
#endif
- EXIT;
return 1;
}
lu_ref_del(&lock->l_reference, "hash", lock);
LDLM_LOCK_RELEASE(lock);
}
- EXIT;
}
/**
lu_ref_del(&lock->l_reference, "hash", lock);
LDLM_LOCK_RELEASE(lock);
}
- EXIT;
}
/* this is called by portals_handle2object with the handle lock taken */
ldlm_add_bl_work_item(lock, new, work_list);
else
ldlm_add_cp_work_item(lock, work_list);
- EXIT;
}
/**
LDLM_DEBUG(lock, "do not add lock into lru list");
unlock_res_and_lock(lock);
}
-
- EXIT;
}
/**
prev->res_link = &mode_end->l_res_link;
prev->mode_link = &mode_end->l_sl_mode;
prev->policy_link = &req->l_sl_policy;
- EXIT;
return;
} else if (lock->l_resource->lr_type == LDLM_IBITS) {
for (;;) {
&policy_end->l_sl_mode;
prev->policy_link =
&policy_end->l_sl_policy;
- EXIT;
return;
}
prev->res_link = &mode_end->l_res_link;
prev->mode_link = &mode_end->l_sl_mode;
prev->policy_link = &req->l_sl_policy;
- EXIT;
return;
} else {
LDLM_ERROR(lock,"is not LDLM_PLAIN or LDLM_IBITS lock");
prev->res_link = queue->prev;
prev->mode_link = &req->l_sl_mode;
prev->policy_link = &req->l_sl_policy;
- EXIT;
return;
}
list_add(&lock->l_sl_mode, prev->mode_link);
if (&lock->l_sl_policy != prev->policy_link)
list_add(&lock->l_sl_policy, prev->policy_link);
-
- EXIT;
}
/**
search_granted_lock(&lock->l_resource->lr_granted, lock, &prev);
ldlm_granted_list_add_lock(lock, &prev);
- EXIT;
}
/**
ldlm_add_ast_work_item(lock, NULL, work_list);
ldlm_pool_add(&ldlm_res_to_ns(res)->ns_pool, lock);
- EXIT;
}
/**
if (lock != NULL)
GOTO(out, rc = 1);
- EXIT;
out:
unlock_res(res);
LDLM_RESOURCE_DELREF(res);
ldlm_lock_addref_internal_nolock(lock, mode);
}
- EXIT;
-
out:
if (lock != NULL) {
unlock_res_and_lock(lock);
cfs_hash_for_each_nolock(ns->ns_rs_hash,
ldlm_reprocess_res, NULL);
}
- EXIT;
}
EXPORT_SYMBOL(ldlm_reprocess_all_ns);
"LDLM_NAMESPACE_SERVER resource type lock.\n");
LBUG();
}
- EXIT;
}
/**
* if not to zero out lock->l_granted_mode */
lock->l_granted_mode = LCK_MINMODE;
unlock_res_and_lock(lock);
-
- EXIT;
}
EXPORT_SYMBOL(ldlm_lock_cancel);
ldlm_grant_lock(lock, NULL);
unlock_res_and_lock(lock);
ldlm_reprocess_all(lock->l_resource);
-
- EXIT;
}
EXPORT_SYMBOL(ldlm_lock_downgrade);
LDLM_DEBUG(lock, "client blocking callback handler END");
LDLM_LOCK_RELEASE(lock);
- EXIT;
}
/**
if (ldlm_bl_to_thread_lock(ns, NULL, lock))
ldlm_handle_bl_callback(ns, NULL, lock);
- EXIT;
return;
}
unlock_res_and_lock(lock);
LDLM_LOCK_RELEASE(lock);
- EXIT;
}
static int ldlm_callback_reply(struct ptlrpc_request *req, int rc)
ldlm_refcount--;
}
mutex_unlock(&ldlm_ref_mutex);
-
- EXIT;
}
EXPORT_SYMBOL(ldlm_put_ref);
exp->exp_lock_hash = NULL;
ldlm_destroy_flock_export(exp);
- EXIT;
}
EXPORT_SYMBOL(ldlm_destroy_export);
"recalc_timing", "sec");
rc = lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats);
- EXIT;
out_free_name:
OBD_FREE(var_name, MAX_STRING_SIZE + 1);
return rc;
* any abnormal using cases.
*/
POISON(pl, 0x5a, sizeof(*pl));
- EXIT;
}
EXPORT_SYMBOL(ldlm_pool_fini);
static void ldlm_pools_thread_stop(void)
{
if (ldlm_pools_thread == NULL) {
- EXIT;
return;
}
wait_for_completion(&ldlm_pools_comp);
OBD_FREE_PTR(ldlm_pools_thread);
ldlm_pools_thread = NULL;
- EXIT;
}
int ldlm_pools_init(void)
lock->l_completion_ast(lock, *flags, NULL);
LDLM_DEBUG(lock, "client-side local enqueue handler, new lock created");
- EXIT;
out:
LDLM_LOCK_RELEASE(lock);
out_nolock:
}
LDLM_DEBUG(lock, "client-side enqueue END");
- EXIT;
cleanup:
if (cleanup_phase == 1 && rc)
failed_lock_cleanup(ns, lock, mode);
} else {
rc = LUSTRE_EDEADLK;
}
- EXIT;
out:
LDLM_LOCK_PUT(lock);
ptlrpc_req_finished(req);
packed++;
}
CDEBUG(D_DLMTRACE, "%d locks packed\n", packed);
- EXIT;
}
/**
}
ptlrpc_req_finished(req);
- EXIT;
out:
return sent ? sent : rc;
}
int rc;
if (!ns) {
- EXIT;
return;
}
rc = __ldlm_namespace_free(ns, 1);
LASSERT(rc == 0);
}
- EXIT;
}
/**
void ldlm_namespace_free_post(struct ldlm_namespace *ns)
{
if (!ns) {
- EXIT;
return;
}
LASSERT(list_empty(&ns->ns_list_chain));
OBD_FREE_PTR(ns);
ldlm_put_ref();
- EXIT;
}
/**
i = cfs_hash_with_bigname(hs) ?
CFS_HASH_BIGNAME_LEN : CFS_HASH_NAME_LEN;
LIBCFS_FREE(hs, offsetof(cfs_hash_t, hs_name[i]));
-
- EXIT;
}
cfs_hash_t *cfs_hash_getref(cfs_hash_t *hs)
CDEBUG(D_HA, "Invoked LNET debug log upcall %s %s\n",
argv[0], argv[1]);
}
-
- EXIT;
}
void libcfs_run_upcall(char **argv)
struct upcall_cache_entry *entry)
{
if (!entry) {
- EXIT;
return;
}
spin_lock(&cache->uc_lock);
put_entry(cache, entry);
spin_unlock(&cache->uc_lock);
- EXIT;
}
EXPORT_SYMBOL(upcall_cache_put_entry);
}
}
spin_unlock(&cache->uc_lock);
- EXIT;
}
void upcall_cache_flush_idle(struct upcall_cache *cache)
LASSERT(lld->lld_mnt_count == 0);
de->d_fsdata = NULL;
call_rcu(&lld->lld_rcu_head, free_dentry_data);
-
- EXIT;
}
/* Compare if two dentries are the same. Don't match if the existing dentry
it->d.lustre.it_disposition = 0;
it->d.lustre.it_data = NULL;
- EXIT;
}
void ll_invalidate_aliases(struct inode *inode)
d_lustre_invalidate(dentry, 0);
}
ll_unlock_dcache(inode);
-
- EXIT;
}
int ll_revalidate_it_finish(struct ptlrpc_request *request,
if (page_pool != &page0)
OBD_FREE(page_pool, sizeof(struct page *) * max_pages);
- EXIT;
return rc;
}
GOTO(out_free, rc);
}
ptlrpc_req_finished(request);
- EXIT;
out_free:
obd_ioctl_freedata(buf, len);
return rc;
GOTO(out_req, rc = -EFAULT);
}
- EXIT;
out_req:
ptlrpc_req_finished(request);
if (filename)
if (copy_to_user(&lumd->lmd_st, &st, sizeof(st)))
GOTO(free_lsm, rc = -EFAULT);
- EXIT;
free_lsm:
obd_free_memmd(sbi->ll_dt_exp, &lsm);
free_lmm:
ll_pack_inode2opdata(inode, op_data, &och->och_fh);
ll_prep_md_op_data(op_data, inode, NULL, NULL,
0, 0, LUSTRE_OPC_ANY, NULL);
- EXIT;
}
static int ll_close_inode_openhandle(struct obd_export *md_exp,
inode->i_ino, rc);
}
- EXIT;
out:
-
if (exp_connect_som(exp) && !epoch_close &&
S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) {
ll_queue_done_writing(inode, LLIF_DONE_WRITING);
}
OBD_FREE_PTR(obdo);
- EXIT;
out:
ccc_inode_lsm_put(inode, lsm);
RETURN(rc);
lock->l_lvb_len = lmmsize;
unlock_res_and_lock(lock);
- EXIT;
-
out:
ptlrpc_req_finished(req);
return rc;
/* refresh layout failed, need to wait */
wait_layout = rc == -EBUSY;
- EXIT;
out:
LDLM_LOCK_PUT(lock);
if (capa_for_oss(capa))
inode_add_oss_capa(inode, ocapa);
DEBUG_CAPA(D_SEC, capa, "renew");
- EXIT;
retry:
list_del_init(&ocapa->c_list);
sort_add_capa(ocapa, ll_capa_list);
list_add(&page->cpg_pending_linkage,
&club->cob_pending_list);
spin_unlock(&lli->lli_lock);
- EXIT;
}
/** records that a write has completed */
spin_unlock(&lli->lli_lock);
if (rc)
ll_queue_done_writing(club->cob_inode, 0);
- EXIT;
}
/** Queues DONE_WRITING if
spin_unlock(&lcq->lcq_lock);
}
spin_unlock(&lli->lli_lock);
- EXIT;
}
/** Pack SOM attributes info @opdata for CLOSE, DONE_WRITING rpc. */
op_data->op_attr.ia_valid |= ATTR_MTIME_SET | ATTR_CTIME_SET |
ATTR_ATIME_SET | ATTR_SIZE | ATTR_BLOCKS;
}
- EXIT;
}
/** Closes ioepoch and packs Size-on-MDS attribute if needed into @op_data. */
spin_unlock(&lli->lli_lock);
ll_done_writing_attr(inode, op_data);
- EXIT;
out:
return;
}
OBD_ALLOC_PTR(op_data);
if (op_data == NULL) {
CERROR("can't allocate op_data\n");
- EXIT;
return;
}
md_clear_open_replay_data(ll_i2sbi(inode)->ll_md_exp, och);
OBD_FREE_PTR(och);
}
- EXIT;
}
static struct ll_inode_info *ll_close_next_lli(struct ll_close_queue *lcq)
spin_unlock(&ll_sb_lock);
OBD_FREE(sbi, sizeof(*sbi));
}
- EXIT;
}
static struct dentry_operations ll_d_root_ops = {
obd_fid_fini(sbi->ll_md_exp->exp_obd);
obd_disconnect(sbi->ll_md_exp);
sbi->ll_md_exp = NULL;
-
- EXIT;
}
void ll_kill_super(struct super_block *sb)
sb->s_dev = sbi->ll_sdev_orig;
sbi->ll_umounting = 1;
}
- EXIT;
}
char *ll_read_opt(const char *opt, char *data)
lustre_common_put_super(sb);
module_put(THIS_MODULE);
-
- EXIT;
} /* client_put_super */
struct inode *ll_inode_from_resource_lock(struct ldlm_lock *lock)
*/
cl_inode_fini(inode);
lli->lli_has_smd = false;
-
- EXIT;
}
int ll_md_setattr(struct dentry *dentry, struct md_op_data *op_data,
* setting times to past, but it is necessary due to possible
* time de-synchronization between MDT inode and OST objects */
rc = ll_setattr_ost(inode, attr);
- EXIT;
out:
if (op_data) {
if (op_data->op_ioepoch) {
inode->i_op = &ll_file_inode_operations;
inode->i_fop = sbi->ll_fop;
inode->i_mapping->a_ops = (struct address_space_operations *)&ll_aops;
- EXIT;
} else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &ll_dir_inode_operations;
inode->i_fop = &ll_dir_operations;
- EXIT;
} else if (S_ISLNK(inode->i_mode)) {
inode->i_op = &ll_fast_symlink_inode_operations;
- EXIT;
} else {
inode->i_op = &ll_special_inode_operations;
init_special_inode(inode, inode->i_mode,
inode->i_rdev);
-
- EXIT;
}
}
ll_clear_inode(inode);
clear_inode(inode);
-
- EXIT;
}
int ll_iocontrol(struct inode *inode, struct file *file,
if (obd == NULL) {
CERROR("Invalid MDC connection handle "LPX64"\n",
sbi->ll_md_exp->exp_handle.h_cookie);
- EXIT;
return;
}
obd->obd_force = 1;
if (obd == NULL) {
CERROR("Invalid LOV connection handle "LPX64"\n",
sbi->ll_dt_exp->exp_handle.h_cookie);
- EXIT;
return;
}
obd->obd_force = 1;
* schedule() and sleep one second if needed, and hope.
*/
schedule();
-
- EXIT;
}
int ll_remount_fs(struct super_block *sb, int *flags, char *data)
spin_unlock(&lli->lli_lock);
}
}
- EXIT;
out_io:
cl_io_fini(env, io);
LASSERT(vma->vm_file);
LASSERT(atomic_read(&vob->cob_mmap_cnt) >= 0);
atomic_inc(&vob->cob_mmap_cnt);
- EXIT;
}
/**
LASSERT(vma->vm_file);
atomic_dec(&vob->cob_mmap_cnt);
LASSERT(atomic_read(&vob->cob_mmap_cnt) >= 0);
- EXIT;
}
mutex_unlock(&dir->i_mutex);
if (!rc && !lgd.lgd_found)
rc = -ENOENT;
- EXIT;
-
out:
return rc;
}
CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
inode, inode->i_ino, inode->i_generation);
ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL);
- EXIT;
out:
ptlrpc_req_finished(request);
return inode;
d_instantiate(dchild, inode);
}
- EXIT;
err_exit:
ptlrpc_req_finished(request);
ll_update_times(request, dir);
ll_stats_ops_tally(sbi, LPROC_LL_LINK, 1);
- EXIT;
out:
ptlrpc_req_finished(request);
RETURN(err);
if ((ras->ras_consecutive_requests > 1 || stride_detect) &&
!ras->ras_request_index)
ras_increase_window(inode, ras, ra);
- EXIT;
out_unlock:
RAS_CDEBUG(ras);
ras->ras_request_index++;
iput(inode);
OBD_FREE_PTR(sai);
}
-
- EXIT;
}
/* Do NOT forget to drop inode refcount when into sai_entries_agl. */
PFID(&lli->lli_fid), index, rc);
iput(inode);
-
- EXIT;
}
static void ll_post_statahead(struct ll_statahead_info *sai)
if (agl_should_run(sai, child))
ll_agl_add(sai, child, entry->se_index);
- EXIT;
-
out:
/* The "ll_sa_entry_to_stated()" will drop related ldlm ibits lock
* reference count by calling "ll_intent_drop_lock()" in spite of the
wake_up(&sai->sai_thread.t_ctl_waitq);
}
- EXIT;
-
out:
if (rc != 0) {
ll_intent_release(it);
sai->sai_index++;
/* drop one refcount on entry by ll_sa_entry_alloc */
ll_sa_entry_put(sai, entry);
-
- EXIT;
}
static int ll_agl_thread(void *arg)
l_wait_event(thread->t_ctl_waitq,
thread_is_running(thread) || thread_is_stopped(thread),
&lwi);
- EXIT;
}
static int ll_statahead_thread(void *arg)
*/
}
}
- EXIT;
out:
if (sai->sai_agl_valid) {
ll_release_page(page, 1);
}
}
- EXIT;
out:
ll_dir_chain_fini(&chain);
if (!thread_is_stopped(thread))
wake_up(&thread->t_ctl_waitq);
-
- EXIT;
}
/**
lu_ref_add(&page->cp_reference, "fault", io);
fio->ft_page = page;
- EXIT;
out:
/* return unlocked vmpage to avoid deadlocking */
if (page->cp_sync_io == NULL)
unlock_page(vmpage);
-
- EXIT;
}
static void vvp_page_completion_write(const struct lu_env *env,
vvp_vmpage_error(ccc_object_inode(pg->cp_obj), vmpage, ioret);
end_page_writeback(vmpage);
- EXIT;
}
/**
memcpy(buffer, xdata, body->eadatasize);
rc = body->eadatasize;
}
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
it->d.lustre.it_lock_handle = plock.cookie;
it->d.lustre.it_lock_mode = pmode;
- EXIT;
out_free_op_data:
OBD_FREE_PTR(op_data);
out:
CDEBUG(D_INFO, "Marking OBD %p %sactive\n", obd,
activate ? "" : "in");
lmv_activate_target(lmv, tgt, activate);
- EXIT;
out_lmv_lock:
spin_unlock(&lmv->lmv_lock);
rc = 0;
}
- EXIT;
out:
mutex_unlock(&tgt->ltd_fid_mutex);
return rc;
}
}
- EXIT;
out_free_temp:
OBD_FREE(temp, sizeof(*temp));
return rc;
rc = md_enqueue(tgt->ltd_exp, einfo, it, rdata, lockh,
lmm, lmmsize, NULL, extra_lock_flags);
OBD_FREE_PTR(rdata);
- EXIT;
out:
ldlm_lock_decref(&plock, pmode);
return rc;
lr = cl2lov_req(slice);
OBD_SLAB_FREE_PTR(lr, lov_req_kmem);
- EXIT;
}
static const struct cl_req_operations lov_req_ops = {
cl_stack_fini(env, lovsub2cl_dev(ld->ld_target[index]));
ld->ld_target[index] = NULL;
}
- EXIT;
}
static struct lov_device_emerg **lov_emerg_alloc(int nr)
cl_env_put(sub->sub_env, &sub->sub_refcheck);
sub->sub_env = NULL;
}
- EXIT;
}
static void lov_io_sub_inherit(struct cl_io *io, struct lov_io *lio,
default:
LBUG();
}
-
- EXIT;
}
static void lov_io_fini(const struct lu_env *env, const struct cl_io_slice *ios)
LASSERT(atomic_read(&lov->lo_active_ios) > 0);
if (atomic_dec_and_test(&lov->lo_active_ios))
wake_up_all(&lov->lo_waitq);
- EXIT;
}
static obd_off lov_offset_mod(obd_off val, int delta)
LASSERT(rc == 0);
while (!list_empty(&lio->lis_active))
list_del_init(lio->lis_active.next);
- EXIT;
}
static void lov_io_unlock(const struct lu_env *env,
rc = lov_io_call(env, cl2lov_io(env, ios), lov_io_unlock_wrapper);
LASSERT(rc == 0);
- EXIT;
}
if (atomic_dec_and_test(&lov->lo_active_ios))
wake_up_all(&lov->lo_waitq);
- EXIT;
}
static void lov_empty_impossible(const struct lu_env *env,
rc = lov_sublock_modify(env, lck, lsl, &sublock->cll_descr, idx);
LASSERT(rc == 0); /* there is no way this can fail, currently */
- EXIT;
}
static struct cl_lock *lov_sublock_alloc(const struct lu_env *env,
lov_sublock_env_put(subenv);
lsl->lss_active = NULL;
cl_lock_disclosure(env, closure);
- EXIT;
}
static int lov_sublock_lock(const struct lu_env *env,
cl_lock_user_add(env, sublock);
cl_lock_put(env, sublock);
}
- EXIT;
}
static void lov_lock_fini(const struct lu_env *env,
lck->lls_nr * sizeof lck->lls_sub[0]);
}
OBD_SLAB_FREE_PTR(lck, lov_lock_kmem);
- EXIT;
}
static int lov_lock_enqueue_wait(const struct lu_env *env,
lu_ref_del(&parent->cll_reference, "lov-child", sub->lss_cl.cls_lock);
cl_lock_put(env, parent);
OBD_SLAB_FREE_PTR(link, lov_lock_link_kmem);
- EXIT;
}
struct lov_lock_link *lov_lock_link_find(const struct lu_env *env,
}
cl_lock_closure_fini(closure);
- EXIT;
}
static int lov_lock_print(const struct lu_env *env, void *cookie,
dump_lsm(D_INODE, lov->lo_lsm);
lov_free_memmd(&lov->lo_lsm);
-
- EXIT;
}
static void lov_fini_released(const struct lu_env *env, struct lov_object *lov,
{
dump_lsm(D_INODE, lov->lo_lsm);
lov_free_memmd(&lov->lo_lsm);
- EXIT;
}
static int lov_print_empty(const struct lu_env *env, void *cookie,
}
lov->lo_layout_invalid = lov_layout_change(env, lov, conf);
- EXIT;
out:
lov_conf_unlock(lov);
struct lov_object *lov = lu2lov(obj);
LOV_2DISPATCH_VOID(lov, llo_delete, env, lov, &lov->u);
- EXIT;
}
static void lov_object_free(const struct lu_env *env, struct lu_object *obj)
LOV_2DISPATCH_VOID(lov, llo_fini, env, lov, &lov->u);
lu_object_fini(obj);
OBD_SLAB_FREE_PTR(lov, lov_object_kmem);
- EXIT;
}
static int lov_object_print(const struct lu_env *env, void *cookie,
slice->cpl_page->cp_child = NULL;
cl_page_put(env, sub);
}
- EXIT;
}
static int lov_page_own(const struct lu_env *env,
LASSERT(0);
}
- EXIT;
out:
return rc;
}
lov_ost_pool_free(&(pool->pool_rr.lqr_pool));
lov_ost_pool_free(&(pool->pool_obds));
OBD_FREE_PTR(pool);
- EXIT;
}
}
op->op_size = 0;
RETURN(-ENOMEM);
}
- EXIT;
return 0;
}
/* ost not found we add it */
op->op_array[op->op_count] = idx;
op->op_count++;
- EXIT;
out:
up_write(&op->op_rw_sem);
return rc;
(op->op_count - i - 1) * sizeof(op->op_array[0]));
op->op_count--;
up_write(&op->op_rw_sem);
- EXIT;
return 0;
}
}
CDEBUG(D_CONFIG, "Added %s to "LOV_POOLNAMEF" as member %d\n",
ostname, poolname, pool_tgt_count(pool));
- EXIT;
out:
obd_putref(obd);
lov_pool_putref(pool);
CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,
poolname);
- EXIT;
out:
obd_putref(obd);
lov_pool_putref(pool);
GOTO(out, rc = 0);
}
rc = -ENOENT;
- EXIT;
out:
up_read(&pool_tgt_rw_sem(pool));
lov_llh_put(set->set_lockh);
OBD_FREE(set, sizeof(*set));
- EXIT;
}
int lov_set_finished(struct lov_request_set *set, int idempotent)
lsr = cl2lovsub_req(slice);
OBD_SLAB_FREE_PTR(lsr, lovsub_req_kmem);
- EXIT;
}
/**
* unconditionally. It never changes anyway.
*/
attr->cra_oa->o_stripe_idx = subobj->lso_index;
- EXIT;
}
static const struct cl_req_operations lovsub_req_ops = {
lsl = cl2lovsub_lock(slice);
LASSERT(list_empty(&lsl->lss_parents));
OBD_SLAB_FREE_PTR(lsl, lovsub_lock_kmem);
- EXIT;
}
static void lovsub_parent_lock(const struct lu_env *env, struct lov_lock *lov)
cl_lock_get(parent);
lu_ref_add(&parent->cll_reference, "lovsub-parent", current);
cl_lock_mutex_get(env, parent);
- EXIT;
}
static void lovsub_parent_unlock(const struct lu_env *env, struct lov_lock *lov)
cl_lock_mutex_put(env, lov->lls_cl.cls_lock);
lu_ref_del(&parent->cll_reference, "lovsub-parent", current);
cl_lock_put(env, parent);
- EXIT;
}
/**
lovsub_parent_unlock(env, lov);
}
}
- EXIT;
}
/**
}
out->cld_start = start;
out->cld_end = end;
- EXIT;
}
/**
}
}
} while (restart);
- EXIT;
}
static int lovsub_lock_print(const struct lu_env *env, void *cookie,
lu_object_fini(obj);
lu_object_header_fini(&los->lso_header.coh_lu);
OBD_SLAB_FREE_PTR(los, lovsub_object_kmem);
- EXIT;
}
static int lovsub_object_print(const struct lu_env *env, void *cookie,
GOTO(out, rc);
rc = mdc_finish_intent_lock(exp, req, &minfo->mi_data, it, lockh);
- EXIT;
out:
OBD_FREE_PTR(einfo);
"root fid="DFID", last_committed="LPU64"\n",
PFID(rootfid),
lustre_msg_get_last_committed(req->rq_repmsg));
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
md->oss_capa = oc;
}
- EXIT;
out:
if (rc) {
if (md->oss_capa) {
if (mod == NULL) {
DEBUG_REQ(D_ERROR, req,
"Can't properly replay without open data.");
- EXIT;
return;
}
DEBUG_REQ(D_HA, close_req, "updating close body with new fh");
epoch->handle = body->handle;
}
- EXIT;
}
void mdc_commit_open(struct ptlrpc_request *req)
GOTO(out, rc = -EPROTO);
*osfs = *msfs;
- EXIT;
out:
ptlrpc_req_finished(req);
output:
*hca = *req_hca;
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
*hus = *req_hus;
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
rc = mdc_queue_wait(req);
GOTO(out, rc);
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- EXIT;
out:
ptlrpc_req_finished(req);
capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA2);
if (!capa)
GOTO(out, capa = ERR_PTR(-EFAULT));
- EXIT;
out:
ra->ra_cb(ra->ra_oc, capa);
return 0;
class_export_put(cld->cld_mgcexp);
OBD_FREE(cld, sizeof(*cld) + strlen(cld->cld_logname) + 1);
}
-
- EXIT;
}
/* Find a config log by name */
cld->cld_logname);
}
up_read(&cld->cld_mgcexp->exp_obd->u.cli.cl_sem);
-
- EXIT;
}
/* this timeout represents how many seconds MGC should wait before
spin_unlock(&config_list_lock);
wake_up(&rq_waitq);
}
- EXIT;
}
/********************** class fns **********************/
be updated here. */
rc = class_config_parse_llog(NULL, ctxt, cld->cld_logname,
&cld->cld_cfg);
- EXIT;
out_pop:
llog_ctxt_put(ctxt);
*out = new;
rc = 0;
}
- EXIT;
_out:
if (rc) {
*out = new;
rc = 0;
}
- EXIT;
_out:
if (rc) {
new->a_count = cpu_to_le32(j);
/* free unused space. */
rc = lustre_ext_acl_xattr_reduce_space(&new, ext_count);
- EXIT;
out:
if (rc) {
GOTO(out, rc);
}
- EXIT;
-
out:
ll_crypto_free_blkcipher(tfm);
return rc;
GOTO(out, rc);
}
- EXIT;
-
out:
ll_crypto_free_blkcipher(tfm);
return rc;
default:
LBUG();
}
- EXIT;
}
EXPORT_SYMBOL(cl_io_fini);
prev = curr;
}
} while (!done);
- EXIT;
}
/**
}
if (link->cill_fini != NULL)
link->cill_fini(env, link);
- EXIT;
}
static int cl_lockset_lock(const struct lu_env *env, struct cl_io *io,
}
io->ci_state = CIS_UNLOCKED;
LASSERT(!cl_env_info(env)->clt_counters[CNL_TOP].ctc_nr_locks_acquired);
- EXIT;
}
EXPORT_SYMBOL(cl_io_unlock);
scan->cis_iop->op[io->ci_type].cio_iter_fini(env, scan);
}
io->ci_state = CIS_IT_ENDED;
- EXIT;
}
EXPORT_SYMBOL(cl_io_iter_fini);
scan->cis_iop->op[io->ci_type].cio_advance(env, scan,
nob);
}
- EXIT;
}
EXPORT_SYMBOL(cl_io_rw_advance);
/* TODO: error handling. */
}
io->ci_state = CIS_IO_FINISHED;
- EXIT;
}
EXPORT_SYMBOL(cl_io_end);
slice->cis_io = io;
slice->cis_obj = obj;
slice->cis_iop = ops;
- EXIT;
}
EXPORT_SYMBOL(cl_io_slice_add);
plist->pl_nr = 0;
INIT_LIST_HEAD(&plist->pl_pages);
plist->pl_owner = current;
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_init);
++plist->pl_nr;
lu_ref_add_at(&page->cp_reference, &page->cp_queue_ref, "queue", plist);
cl_page_get(page);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_add);
--plist->pl_nr;
lu_ref_del_at(&page->cp_reference, &page->cp_queue_ref, "queue", plist);
cl_page_put(env, page);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_del);
++dst->pl_nr;
lu_ref_set_at(&page->cp_reference, &page->cp_queue_ref, "queue",
src, dst);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_move);
cl_page_list_for_each_safe(page, tmp, list)
cl_page_list_move(head, list, page);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_splice);
plist);
cl_page_put(env, page);
}
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_disown);
cl_page_list_for_each_safe(page, temp, plist)
cl_page_list_del(env, plist, page);
LASSERT(plist->pl_nr == 0);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_fini);
LINVRNT(plist->pl_owner == current);
cl_page_list_for_each(page, plist)
cl_page_discard(env, io, page);
- EXIT;
}
EXPORT_SYMBOL(cl_page_list_discard);
{
cl_page_list_init(&queue->c2_qin);
cl_page_list_init(&queue->c2_qout);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_init);
void cl_2queue_add(struct cl_2queue *queue, struct cl_page *page)
{
cl_page_list_add(&queue->c2_qin, page);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_add);
{
cl_page_list_disown(env, io, &queue->c2_qin);
cl_page_list_disown(env, io, &queue->c2_qout);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_disown);
{
cl_page_list_discard(env, io, &queue->c2_qin);
cl_page_list_discard(env, io, &queue->c2_qout);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_discard);
{
cl_page_list_fini(env, &queue->c2_qout);
cl_page_list_fini(env, &queue->c2_qin);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_fini);
{
cl_2queue_init(queue);
cl_2queue_add(queue, page);
- EXIT;
}
EXPORT_SYMBOL(cl_2queue_init_page);
slice->crs_dev = dev;
slice->crs_ops = ops;
slice->crs_req = req;
- EXIT;
}
EXPORT_SYMBOL(cl_req_slice_add);
OBD_FREE(req->crq_o, req->crq_nrobjs * sizeof req->crq_o[0]);
}
OBD_FREE_PTR(req);
- EXIT;
}
static int cl_req_init(const struct lu_env *env, struct cl_req *req,
slice->crs_ops->cro_completion(env, slice, rc);
}
cl_req_free(env, req);
- EXIT;
}
EXPORT_SYMBOL(cl_req_completion);
}
}
LASSERT(i < req->crq_nrobjs);
- EXIT;
}
EXPORT_SYMBOL(cl_req_page_add);
list_del_init(&page->cp_flight);
--req->crq_nrpages;
page->cp_req = NULL;
- EXIT;
}
EXPORT_SYMBOL(cl_req_page_done);
attr + i, flags);
}
}
- EXIT;
}
EXPORT_SYMBOL(cl_req_attr_set);
atomic_set(&anchor->csi_sync_nr, nrpages);
atomic_set(&anchor->csi_barrier, nrpages > 0);
anchor->csi_sync_rc = 0;
- EXIT;
}
EXPORT_SYMBOL(cl_sync_io_init);
/* it's safe to nuke or reuse anchor now */
atomic_set(&anchor->csi_barrier, 0);
}
- EXIT;
}
EXPORT_SYMBOL(cl_sync_io_note);
list_add_tail(&slice->cls_linkage, &lock->cll_layers);
slice->cls_obj = obj;
slice->cls_ops = ops;
- EXIT;
}
EXPORT_SYMBOL(cl_lock_slice_add);
lu_ref_fini(&lock->cll_holders);
mutex_destroy(&lock->cll_guard);
OBD_SLAB_FREE_PTR(lock, cl_lock_kmem);
- EXIT;
}
/**
}
CS_LOCK_DEC(obj, busy);
}
- EXIT;
}
EXPORT_SYMBOL(cl_lock_put);
slice->cls_ops->clo_cancel(env, slice);
}
}
- EXIT;
}
static void cl_lock_delete0(const struct lu_env *env, struct cl_lock *lock)
* existing references goes away.
*/
}
- EXIT;
}
/**
cl_lock_delete0(env, lock);
}
}
- EXIT;
}
EXPORT_SYMBOL(cl_lock_hold_release);
if (slice->cls_ops->clo_state != NULL)
slice->cls_ops->clo_state(env, slice, state);
wake_up_all(&lock->cll_wq);
- EXIT;
}
/**
{
cl_lock_trace(D_DLMTRACE, env, "state signal lock", lock);
cl_lock_state_signal(env, lock, lock->cll_state);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_signal);
cl_lock_state_signal(env, lock, state);
lock->cll_state = state;
}
- EXIT;
}
EXPORT_SYMBOL(cl_lock_state_set);
result = cl_unuse_try(env, lock);
if (result)
CL_LOCK_DEBUG(D_ERROR, env, lock, "unuse return %d\n", result);
-
- EXIT;
}
/**
cl_unuse_locked(env, lock);
cl_lock_mutex_put(env, lock);
cl_lock_lockdep_release(env, lock);
- EXIT;
}
EXPORT_SYMBOL(cl_unuse);
cl_lock_delete0(env, lock);
else
lock->cll_flags |= CLF_DOOMED;
- EXIT;
}
EXPORT_SYMBOL(cl_lock_delete);
cl_lock_cancel(env, lock);
cl_lock_delete(env, lock);
}
- EXIT;
}
EXPORT_SYMBOL(cl_lock_error);
cl_lock_cancel0(env, lock);
else
lock->cll_flags |= CLF_CANCELPEND;
- EXIT;
}
EXPORT_SYMBOL(cl_lock_cancel);
spin_lock(&head->coh_lock_guard);
}
spin_unlock(&head->coh_lock_guard);
- EXIT;
}
EXPORT_SYMBOL(cl_locks_prune);
cl_lock_get(lock);
lu_ref_add(&lock->cll_holders, scope, source);
lu_ref_add(&lock->cll_reference, scope, source);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_hold_add);
cl_lock_hold_release(env, lock, scope, source);
lu_ref_del(&lock->cll_reference, scope, source);
cl_lock_put(env, lock);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_unhold);
cl_lock_mutex_put(env, lock);
lu_ref_del(&lock->cll_reference, scope, source);
cl_lock_put(env, lock);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_release);
LINVRNT(cl_lock_invariant(env, lock));
cl_lock_used_mod(env, lock, +1);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_user_add);
cl_lock_used_mod(env, lock, -1);
if (lock->cll_users == 0)
wake_up_all(&lock->cll_wq);
- EXIT;
}
EXPORT_SYMBOL(cl_lock_user_del);
{
cl_pages_prune(env, obj);
cl_locks_prune(env, obj, 1);
- EXIT;
}
EXPORT_SYMBOL(cl_object_prune);
lvb->lvb_atime = attr->cat_atime;
lvb->lvb_ctime = attr->cat_ctime;
lvb->lvb_blocks = attr->cat_blocks;
- EXIT;
}
EXPORT_SYMBOL(cl_attr2lvb);
attr->cat_atime = lvb->lvb_atime;
attr->cat_ctime = lvb->lvb_ctime;
attr->cat_blocks = lvb->lvb_blocks;
- EXIT;
}
EXPORT_SYMBOL(cl_lvb2attr);
cl_object_put(env, obj);
lu_ref_fini(&page->cp_reference);
OBD_FREE(page, pagesize);
- EXIT;
}
/**
CS_PAGESTATE_INC(page->cp_obj, state);
cl_page_state_set_trust(page, state);
}
- EXIT;
}
static void cl_page_state_set(const struct lu_env *env,
void cl_page_get(struct cl_page *page)
{
cl_page_get_trust(page);
- EXIT;
}
EXPORT_SYMBOL(cl_page_get);
*/
cl_page_free(env, page);
}
-
- EXIT;
}
EXPORT_SYMBOL(cl_page_put);
CL_PAGE_INVOID(env, page, op,
(const struct lu_env *,
const struct cl_page_slice *, struct cl_io *), io);
- EXIT;
}
static void cl_page_owner_clear(struct cl_page *page)
page->cp_task = NULL;
}
}
- EXIT;
}
static void cl_page_owner_set(struct cl_page *page)
LASSERT(page->cp_owner != NULL);
page->cp_owner->ci_owned_nr++;
}
- EXIT;
}
void cl_page_disown0(const struct lu_env *env,
(const struct lu_env *,
const struct cl_page_slice *, struct cl_io *),
io);
- EXIT;
}
/**
pg->cp_task = current;
cl_page_owner_set(pg);
cl_page_state_set(env, pg, CPS_OWNED);
- EXIT;
}
EXPORT_SYMBOL(cl_page_assume);
(const struct lu_env *,
const struct cl_page_slice *, struct cl_io *),
io);
- EXIT;
}
EXPORT_SYMBOL(cl_page_unassume);
pg = cl_page_top(pg);
io = cl_io_top(io);
cl_page_disown0(env, io, pg);
- EXIT;
}
EXPORT_SYMBOL(cl_page_disown);
cl_page_put(env, tmp);
}
}
-
- EXIT;
}
/**
{
PINVRNT(env, pg, cl_page_invariant(pg));
cl_page_delete0(env, pg, 1);
- EXIT;
}
EXPORT_SYMBOL(cl_page_delete);
*/
cl_page_owner_clear(pg);
cl_page_state_set(env, pg, cl_req_type_state(crt));
- EXIT;
}
/**
if (anchor)
cl_sync_io_note(anchor, ioret);
-
- EXIT;
}
EXPORT_SYMBOL(cl_page_completion);
slice->cpl_obj = obj;
slice->cpl_ops = ops;
slice->cpl_page = page;
- EXIT;
}
EXPORT_SYMBOL(cl_page_slice_add);
CDEBUG((pages_leaked) ? D_ERROR : D_INFO,
"obd_memory_pages max: "LPU64", leaked: "LPU64"\n",
pages_max, pages_leaked);
-
- EXIT;
}
MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
kmem_cache_destroy(capa_cachep);
capa_cachep = NULL;
}
- EXIT;
}
int obd_init_caches(void)
class_decref(obd, "export", exp);
OBD_FREE_RCU(exp, sizeof(*exp), &exp->exp_handle);
- EXIT;
}
static void export_handle_addref(void *export)
LASSERT(imp->imp_sec == NULL);
class_decref(imp->imp_obd, "import", imp);
OBD_FREE_RCU(imp, sizeof(*imp), &imp->imp_handle);
- EXIT;
}
static void import_handle_addref(void *import)
/* catch possible import put race */
LASSERT_ATOMIC_GE_LT(&imp->imp_refcount, 0, LI_POISON);
- EXIT;
}
EXPORT_SYMBOL(class_import_put);
obd_export_nid2str(exp), exp, rc);
class_export_put(exp);
}
- EXIT;
}
void class_disconnect_exports(struct obd_device *obd)
} else
CDEBUG(D_HA, "OBD device %d (%p) has no exports\n",
obd->obd_minor, obd);
- EXIT;
}
EXPORT_SYMBOL(class_disconnect_exports);
class_disconnect_export_list(&work_list, exp_flags_from_obd(obd) |
OBD_OPT_ABORT_RECOV);
- EXIT;
}
EXPORT_SYMBOL(class_disconnect_stale_exports);
cond_resched();
} while (import != NULL || export != NULL);
- EXIT;
}
static struct completion obd_zombie_start;
data->ioc_inlbuf4 = &data->ioc_bulk[0] + offset;
}
- EXIT;
return 0;
}
EXPORT_SYMBOL(obd_ioctl_getdata);
loghandle->u.phd.phd_cookie.lgc_lgl = cathandle->lgh_id;
loghandle->u.phd.phd_cookie.lgc_index =
loghandle->lgh_hdr->llh_cat_idx;
- EXIT;
out:
llog_handle_get(loghandle);
*res = loghandle;
GOTO(out, rc);
}
- EXIT;
out:
lu_object_put(env, &o->do_lu);
RETURN(rc);
__swab32s (&d->lgd_len);
__swab64s (&d->lgd_cur_offset);
print_llogd_body(d);
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_llogd_body);
lustre_swab_llog_rec(&h->llh_hdr);
print_llog_hdr(h);
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_llog_hdr);
for (i = 0; i < lcfg->lcfg_bufcount; i++)
CDEBUG(D_OTHER, "\tlcfg->lcfg_buflens[%d]: %d\n",
i, lcfg->lcfg_buflens[i]);
- EXIT;
}
void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg)
if (lcfg->lcfg_version != LUSTRE_CFG_VERSION) {
CERROR("not swabbing lustre_cfg version %#x (expecting %#x)\n",
lcfg->lcfg_version, LUSTRE_CFG_VERSION);
- EXIT;
return;
}
__swab32s(&lcfg->lcfg_buflens[i]);
print_lustre_cfg(lcfg);
- EXIT;
return;
}
EXPORT_SYMBOL(lustre_swab_lustre_cfg);
__swab64s(&marker->cm_canceltime);
}
- EXIT;
return;
}
EXPORT_SYMBOL(lustre_swab_cfg_marker);
cfs_hash_del(hash, &stat->nid, &stat->nid_hash);
lprocfs_free_client_stats(stat);
}
- EXIT;
}
EXPORT_SYMBOL(lprocfs_free_per_client_stats);
CDEBUG(D_INFO, "added object %p with handle "LPX64" to hash\n",
h, h->h_cookie);
- EXIT;
}
EXPORT_SYMBOL(class_handle_hash);
list_add_rcu(&h->h_link, &bucket->head);
h->h_in = 1;
spin_unlock(&bucket->lock);
-
- EXIT;
}
EXPORT_SYMBOL(class_handle_hash_back);
OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
OBD_FREE(lprof, sizeof *lprof);
}
- EXIT;
}
EXPORT_SYMBOL(class_del_profile);
OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
OBD_FREE(lprof, sizeof *lprof);
}
- EXIT;
}
EXPORT_SYMBOL(class_del_profiles);
atomic_dec(&eco->eo_npages);
page_cache_release(vmpage);
- EXIT;
}
static int echo_page_prep(const struct lu_env *env,
if (eco->eo_lsm)
echo_free_memmd(eco->eo_dev, &eco->eo_lsm);
OBD_SLAB_FREE_PTR(eco, echo_object_kmem);
- EXIT;
}
static int echo_object_print(const struct lu_env *env, void *cookie,
result = cl_echo_enqueue0(env, eco, start, end, mode, cookie, 0);
cl_io_fini(env, io);
- EXIT;
out:
cl_env_put(env, &refcheck);
return result;
}
cl_echo_cancel0(env, ed, lh.cookie);
- EXIT;
error_lock:
cl_2queue_discard(env, io, queue);
cl_2queue_disown(env, io, queue);
}
CDEBUG(D_RPCTRACE, "End creating object "DFID" %s %p rc = %d\n",
PFID(lu_object_fid(&parent->mo_lu)), lname->ln_name, parent, rc);
- EXIT;
out_put:
lu_object_put(env, ec_child);
return rc;
cl_echo_object_put(eco);
CDEBUG(D_INFO, "oa oid "DOSTID"\n", POSTID(&oa->o_oi));
- EXIT;
failed:
if (created && rc)
GOTO (out, rc = -ENOTTY);
}
- EXIT;
out:
lu_env_fini(env);
OBD_FREE_PTR(env);
goto restart;
}
- EXIT;
out:
osc_extent_put(env, cur);
LASSERT(*grants >= 0);
EASSERTF(osc_extent_is_overlapped(obj, ext) == 0, ext,
"overlapped after expanding for %lu.\n", index);
- EXIT;
out:
osc_object_unlock(obj);
{
LASSERT(spin_is_locked(&cli->cl_loi_list_lock.lock));
if (!(pga->flag & OBD_BRW_FROM_GRANT)) {
- EXIT;
return;
}
atomic_dec(&obd_dirty_transit_pages);
cli->cl_dirty_transit -= PAGE_CACHE_SIZE;
}
- EXIT;
}
/**
if (osc_enter_cache_try(cli, oap, bytes, 0))
GOTO(out, rc = 0);
}
- EXIT;
out:
client_obd_list_unlock(&cli->cl_loi_list_lock);
OSC_DUMP_GRANT(cli, "returned %d.\n", rc);
wake_up(&ocw->ocw_waitq);
}
-
- EXIT;
}
static int osc_max_rpc_in_flight(struct client_obd *cli, struct osc_object *osc)
if (rc)
CERROR("completion on oap %p obj %p returns %d.\n",
oap, osc, rc);
-
- EXIT;
}
/**
unplug = true;
}
rc = 0;
- EXIT;
out:
osc_object_unlock(obj);
cl_object_attr_set(env, obj, attr, valid);
cl_object_attr_unlock(obj);
-
- EXIT;
}
/**
LINVRNT(osc_lock_invariant(olck));
lock_res_and_lock(dlmlock);
}
- EXIT;
}
static void osc_lock_upcall0(const struct lu_env *env, struct osc_lock *olck)
spin_unlock(&obj->oo_seatbelt);
osc_lru_del(osc_cli(obj), opg, true);
- EXIT;
}
void osc_page_clip(const struct lu_env *env, const struct cl_page_slice *slice,
oinfo->oi_oa->o_blksize = cli_brw_size(exp->exp_obd);
oinfo->oi_oa->o_valid |= OBD_MD_FLBLKSZ;
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
lustre_get_wire_obdo(&req->rq_import->imp_connect_data, oinfo->oi_oa,
&body->oa);
- EXIT;
out:
ptlrpc_req_finished(req);
RETURN(rc);
*/
ptlrpcd_add_req(req, pol, -1);
rc = 0;
- EXIT;
out:
if (mem_tight != 0)
*osfs = *msfs;
- EXIT;
out:
ptlrpc_req_finished(req);
return rc;
OBD_FREE(desc, offsetof(struct ptlrpc_bulk_desc,
bd_iov[desc->bd_max_iov]));
- EXIT;
}
EXPORT_SYMBOL(__ptlrpc_free_bulk);
LASSERT(atomic_read(&set->set_remaining) == 0);
ptlrpc_reqset_put(set);
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_set_destroy);
lustre_msg_set_versions(reqmsg, versions);
CDEBUG(D_INFO, "Client save versions ["LPX64"/"LPX64"]\n",
versions[0], versions[1]);
-
- EXIT;
}
/**
static void __ptlrpc_free_req(struct ptlrpc_request *request, int locked)
{
if (request == NULL) {
- EXIT;
return;
}
__ptlrpc_free_req_to_pool(request);
else
OBD_FREE(request, sizeof(*request));
- EXIT;
}
static int __ptlrpc_req_finished(struct ptlrpc_request *request, int locked);
imp->imp_generation == imp->imp_last_generation_checked) {
CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno);
- EXIT;
return;
}
CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n",
list_del_init(&req->rq_replay_list);
__ptlrpc_req_finished(req, 1);
}
-
- EXIT;
- return;
}
void ptlrpc_cleanup_client(struct obd_import *imp)
{
- EXIT;
- return;
}
EXPORT_SYMBOL(ptlrpc_cleanup_client);
ptlrpc_free_committed(imp);
spin_unlock(&imp->imp_lock);
-
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_abort_inflight);
OBD_FREE_PTR(conn);
conn = conn2;
}
- EXIT;
out:
CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
conn, atomic_read(&conn->c_refcount),
}
EXPORT_SYMBOL(ptlrpc_connection_init);
-void ptlrpc_connection_fini(void) {
+void ptlrpc_connection_fini(void)
+{
cfs_hash_putref(conn_hash);
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_connection_fini);
}
ptlrpc_req_finished(req);
-
- EXIT;
}
/*
* since we don't have our own ref */
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
- EXIT;
}
/*
ptlrpc_client_wake_req(desc->bd_req);
spin_unlock(&desc->bd_lock);
- EXIT;
}
/*
wake_up(&svcpt->scp_waitq);
spin_unlock(&svcpt->scp_lock);
- EXIT;
}
/*
* net's ref on 'rs' */
LASSERT (ev->unlinked);
ptlrpc_rs_decref(rs);
- EXIT;
return;
}
spin_unlock(&rs->rs_lock);
spin_unlock(&svcpt->scp_rep_lock);
}
- EXIT;
}
spin_unlock(&sec->ps_lock);
dispose_ctx_list_kr(&freelist);
- EXIT;
}
static
spin_unlock(&sec->ps_lock);
dispose_ctx_list_kr(&freelist);
- EXIT;
- return;
}
static
{
LASSERT(key->payload.data == NULL);
CDEBUG(D_SEC, "destroy key %p\n", key);
- EXIT;
}
static
spin_unlock(&gsec->gs_base.ps_lock);
ctx_list_destroy_pf(&freelist);
- EXIT;
}
static
}
sec->ps_gc_next = cfs_time_current_sec() + sec->ps_gc_interval;
- EXIT;
}
static
LASSERT(atomic_read(&gmsg->gum_refcount) > 0);
if (!atomic_dec_and_test(&gmsg->gum_refcount)) {
- EXIT;
return;
}
LASSERT(list_empty(&gmsg->gum_list));
LASSERT(list_empty(&gmsg->gum_base.list));
OBD_FREE_PTR(gmsg);
- EXIT;
}
static
/* normally errno is >= 0 */
if (msg->errno >= 0) {
- EXIT;
return;
}
}
gss_msg_fail_ctx(gmsg);
gss_release_msg(gmsg);
- EXIT;
}
static
upcall_list_lock(idx);
}
upcall_list_unlock(idx);
- EXIT;
}
static struct rpc_pipe_ops gss_upcall_ops = {
}
}
write_unlock(&rsc_cache.hash_lock);
- EXIT;
}
static int match_uid(struct rsc *rscp, long uid)
if (SPTLRPC_FLVR_BULK_SVC(sec->ps_flvr.sf_rpc) == SPTLRPC_BULK_SVC_PRIV)
sptlrpc_enc_pool_del_user();
-
- EXIT;
}
void gss_sec_kill(struct ptlrpc_sec *sec)
req->rq_reqbuf = NULL;
req->rq_reqbuf_len = 0;
}
-
- EXIT;
}
static int do_alloc_repbuf(struct ptlrpc_request *req, int bufsize)
struct gss_svc_reqctx *grctx;
if (svc_ctx == NULL) {
- EXIT;
return;
}
CWARN("gss svc invalidate ctx %p(%u)\n",
grctx->src_ctx, grctx->src_ctx->gsc_uid);
gss_svc_upcall_destroy_ctx(grctx->src_ctx);
-
- EXIT;
}
static inline
ptlrpc_abort_inflight(imp);
obd_import_event(imp->imp_obd, imp, IMP_EVENT_INACTIVE);
-
- EXIT;
}
/*
ptlrpc_pinger_wake_up();
}
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_fail_import);
imp->imp_generation++;
spin_unlock(&imp->imp_lock);
ptlrpc_abort_inflight(imp);
-
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_cleanup_imp);
lgh->lgh_id = body->lgd_logid;
lgh->lgh_ctxt = ctxt;
- EXIT;
out:
LLOG_CLIENT_EXIT(ctxt, imp);
ptlrpc_req_finished(req);
*cur_offset = body->lgd_cur_offset;
memcpy(buf, ptr, len);
- EXIT;
out:
ptlrpc_req_finished(req);
err_exit:
GOTO(out, rc =-EFAULT);
memcpy(buf, ptr, len);
- EXIT;
out:
ptlrpc_req_finished(req);
err_exit:
CERROR("you may need to re-run lconf --write_conf.\n");
rc = -EIO;
}
- EXIT;
out:
ptlrpc_req_finished(req);
err_exit:
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
- EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_pop:
&repbody->lgd_cur_offset, ptr, LLOG_CHUNK_SIZE);
if (rc)
GOTO(out_close, rc);
- EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_pop:
if (rc)
GOTO(out_close, rc);
- EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_pop:
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
*hdr = *loghandle->lgh_hdr;
- EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_pop:
if (atomic_dec_and_test(&policy->pol_desc->pd_refs))
module_put(policy->pol_desc->pd_owner);
-
- EXIT;
}
static int nrs_policy_stop_locked(struct ptlrpc_nrs_policy *policy)
struct ptlrpc_nrs_policy *tmp = nrs->nrs_policy_primary;
if (tmp == NULL) {
- EXIT;
return;
}
if (tmp->pol_ref == 0)
nrs_policy_stop0(tmp);
- EXIT;
}
/**
if (opc != OBD_PING)
DEBUG_REQ(D_NET, req, "high priority req");
spin_unlock(&req->rq_lock);
- EXIT;
}
/**
if (hp)
OBD_FREE_PTR(nrs);
-
- EXIT;
}
/**
* returned false.
*/
nrs_resource_put_safe(res1);
- EXIT;
}
/**
__swab16s(&lum->lmm_stripe_count);
__swab16s(&lum->lmm_stripe_offset);
print_lum(lum);
- EXIT;
}
void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
{
CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n");
lustre_swab_lov_user_md_common(lum);
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n");
lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum);
/* lmm_pool_name nothing to do with char */
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
__swab32s(&lmm->lmm_stripe_size);
__swab16s(&lmm->lmm_stripe_count);
__swab16s(&lmm->lmm_layout_gen);
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_lov_mds_md);
__swab32s(&(lod[i].l_ost_gen));
__swab32s(&(lod[i].l_ost_idx));
}
- EXIT;
}
EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
thread_is_event(thread),
&lwi);
if (thread_test_and_clear_flags(thread, SVC_STOPPING)) {
- EXIT;
break;
} else {
/* woken after adding import to reset timer */
{
if (!test_bit(LIOD_START, &pc->pc_flags)) {
CWARN("Thread for pc %p was not started\n", pc);
- goto out;
+ return;
}
set_bit(LIOD_STOP, &pc->pc_flags);
if (force)
set_bit(LIOD_FORCE, &pc->pc_flags);
wake_up(&pc->pc_set->set_waitq);
-
-out:
- EXIT;
}
void ptlrpcd_free(struct ptlrpcd_ctl *pc)
pc->pc_partners = NULL;
}
pc->pc_npartners = 0;
- EXIT;
}
static void ptlrpcd_fini(void)
OBD_FREE(ptlrpcds, ptlrpcds->pd_size);
ptlrpcds = NULL;
}
-
- EXIT;
}
static int ptlrpcd_init(void)
{
CDEBUG(D_HA, "%s: starting recovery\n", obd2cli_tgt(imp->imp_obd));
ptlrpc_connect_import(imp);
-
- EXIT;
}
/**
if (!failed_req->rq_no_resend)
failed_req->rq_resend = 1;
spin_unlock(&failed_req->rq_lock);
-
- EXIT;
}
/**
CDEBUG(D_HA, "%s: recovery finished\n",
obd2cli_tgt(imp->imp_obd));
}
- EXIT;
out:
return rc;
sptlrpc_cli_ctx_put(req->rq_cli_ctx, sync);
req->rq_cli_ctx = NULL;
- EXIT;
}
static
policy = ctx->cc_sec->ps_policy;
policy->sp_cops->free_repbuf(ctx->cc_sec, req);
req->rq_repmsg = NULL;
- EXIT;
}
int sptlrpc_cli_install_rvs_ctx(struct obd_import *imp,
if (prealloc)
lustre_put_emerg_rs(rs);
- EXIT;
}
void sptlrpc_svc_ctx_addref(struct ptlrpc_request *req)
}
up_read(&obd->u.cli.cl_sem);
- EXIT;
}
EXPORT_SYMBOL(sptlrpc_conf_client_adapt);
class_import_put(sec->ps_import);
OBD_FREE_PTR(plsec);
- EXIT;
}
static
req->rq_reqbuf = NULL;
req->rq_reqbuf_len = 0;
}
- EXIT;
}
static
OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len);
req->rq_repbuf = NULL;
req->rq_repbuf_len = 0;
- EXIT;
}
static
if (!rs->rs_prealloc)
OBD_FREE_LARGE(rs, rs->rs_size);
- EXIT;
}
static
spin_unlock(&hrt->hrt_lock);
wake_up(&hrt->hrt_waitq);
- EXIT;
}
void
rs->rs_scheduled_ever = 1; /* flag any notification attempt */
if (rs->rs_scheduled) { /* being set up or already notified */
- EXIT;
return;
}
rs->rs_scheduled = 1;
list_del_init(&rs->rs_list);
ptlrpc_dispatch_difficult_reply(rs);
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply);
}
spin_unlock(&exp->exp_uncommitted_replies_lock);
rs_batch_fini(&batch);
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_commit_replies);
if (exp->exp_obd->obd_recovering) {
/* be nice to everyone during recovery */
- EXIT;
return;
}
exp->exp_obd->obd_eviction_timer = 0;
}
}
-
- EXIT;
}
/**
list_del_init(&req->rq_exp_list);
spin_unlock_bh(&req->rq_export->exp_rpc_lock);
}
- EXIT;
}
static int ptlrpc_hpreq_check(struct ptlrpc_request *req)
list_del(&thread->t_link);
OBD_FREE_PTR(thread);
}
- EXIT;
}
/**
if (svcpt->scp_service != NULL)
ptlrpc_svcpt_stop_threads(svcpt);
}
-
- EXIT;
}
EXPORT_SYMBOL(ptlrpc_stop_all_threads);
projects / linux-block.git / commitdiff