hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

libceph: wrap auth ops in wrapper functions 

Use wrapper functions that check whether the auth op exists so that callers
do not need a bunch of conditional checks.  Simplifies the external
interface.

Signed-off-by: Sage Weil <sage@inktank.com>
Reviewed-by: Alex Elder <elder@inktank.com>
This commit is contained in:
Sage Weil 2013-03-25 10:26:14 -07:00
parent 0bed9b5c52
commit 27859f9773
6 changed files with 84 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
fs/ceph/mds_client.c
View File

@ -365,9 +365,9 @@ void ceph_put_mds_session(struct ceph_mds_session *s)
atomic_read(&s->s_ref), atomic_read(&s->s_ref)-1); atomic_read(&s->s_ref), atomic_read(&s->s_ref)-1);
if (atomic_dec_and_test(&s->s_ref)) { if (atomic_dec_and_test(&s->s_ref)) {
if (s->s_auth.authorizer) if (s->s_auth.authorizer)
s->s_mdsc->fsc->client->monc.auth->ops->destroy_authorizer( ceph_auth_destroy_authorizer(
s->s_mdsc->fsc->client->monc.auth, s->s_mdsc->fsc->client->monc.auth,
s->s_auth.authorizer); s->s_auth.authorizer);
kfree(s); kfree(s);
} }
} }
@ -3439,18 +3439,17 @@ static struct ceph_auth_handshake *get_authorizer(struct ceph_connection *con,
struct ceph_auth_handshake *auth = &s->s_auth; struct ceph_auth_handshake *auth = &s->s_auth;
if (force_new && auth->authorizer) { if (force_new && auth->authorizer) {
if (ac->ops && ac->ops->destroy_authorizer) ceph_auth_destroy_authorizer(ac, auth->authorizer);
ac->ops->destroy_authorizer(ac, auth->authorizer);
auth->authorizer = NULL; auth->authorizer = NULL;
} }
if (!auth->authorizer && ac->ops && ac->ops->create_authorizer) { if (!auth->authorizer) {
int ret = ac->ops->create_authorizer(ac, CEPH_ENTITY_TYPE_MDS, int ret = ceph_auth_create_authorizer(ac, CEPH_ENTITY_TYPE_MDS,
auth); auth);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
} else if (ac->ops && ac->ops_update_authorizer) { } else {
int ret = ac->ops->update_authorizer(ac, CEPH_ENTITY_TYPE_MDS, int ret = ceph_auth_update_authorizer(ac, CEPH_ENTITY_TYPE_MDS,
auth); auth);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
} }
@ -3466,7 +3465,7 @@ static int verify_authorizer_reply(struct ceph_connection *con, int len)
struct ceph_mds_client *mdsc = s->s_mdsc; struct ceph_mds_client *mdsc = s->s_mdsc;
struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth; struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
return ac->ops->verify_authorizer_reply(ac, s->s_auth.authorizer, len); return ceph_auth_verify_authorizer_reply(ac, s->s_auth.authorizer, len);
} }
static int invalidate_authorizer(struct ceph_connection *con) static int invalidate_authorizer(struct ceph_connection *con)
@ -3475,8 +3474,7 @@ static int invalidate_authorizer(struct ceph_connection *con)
struct ceph_mds_client *mdsc = s->s_mdsc; struct ceph_mds_client *mdsc = s->s_mdsc;
struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth; struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
if (ac->ops->invalidate_authorizer) ceph_auth_invalidate_authorizer(ac, CEPH_ENTITY_TYPE_MDS);
ac->ops->invalidate_authorizer(ac, CEPH_ENTITY_TYPE_MDS);
return ceph_monc_validate_auth(&mdsc->fsc->client->monc); return ceph_monc_validate_auth(&mdsc->fsc->client->monc);
} }

13
include/linux/ceph/auth.h
View File

@ -97,5 +97,18 @@ extern int ceph_build_auth(struct ceph_auth_client *ac,
void *msg_buf, size_t msg_len); void *msg_buf, size_t msg_len);
extern int ceph_auth_is_authenticated(struct ceph_auth_client *ac); extern int ceph_auth_is_authenticated(struct ceph_auth_client *ac);
extern int ceph_auth_create_authorizer(struct ceph_auth_client *ac,
int peer_type,
struct ceph_auth_handshake *auth);
extern void ceph_auth_destroy_authorizer(struct ceph_auth_client *ac,
struct ceph_authorizer *a);
extern int ceph_auth_update_authorizer(struct ceph_auth_client *ac,
int peer_type,
struct ceph_auth_handshake *a);
extern int ceph_auth_verify_authorizer_reply(struct ceph_auth_client *ac,
struct ceph_authorizer *a,
size_t len);
extern void ceph_auth_invalidate_authorizer(struct ceph_auth_client *ac,
int peer_type);
#endif #endif

47
net/ceph/auth.c
View File

@ -257,3 +257,50 @@ int ceph_auth_is_authenticated(struct ceph_auth_client *ac)
return 0; return 0;
return ac->ops->is_authenticated(ac); return ac->ops->is_authenticated(ac);
} }
EXPORT_SYMBOL(ceph_auth_is_authenticated);
int ceph_auth_create_authorizer(struct ceph_auth_client *ac,
int peer_type,
struct ceph_auth_handshake *auth)
{
if (ac->ops && ac->ops->create_authorizer)
return ac->ops->create_authorizer(ac, peer_type, auth);
return 0;
}
EXPORT_SYMBOL(ceph_auth_create_authorizer);
void ceph_auth_destroy_authorizer(struct ceph_auth_client *ac,
struct ceph_authorizer *a)
{
if (ac->ops && ac->ops->destroy_authorizer)
ac->ops->destroy_authorizer(ac, a);
}
EXPORT_SYMBOL(ceph_auth_destroy_authorizer);
int ceph_auth_update_authorizer(struct ceph_auth_client *ac,
int peer_type,
struct ceph_auth_handshake *a)
{
int ret = 0;
if (ac->ops && ac->ops->update_authorizer)
ret = ac->ops->update_authorizer(ac, peer_type, a);
return ret;
}
EXPORT_SYMBOL(ceph_auth_update_authorizer);
int ceph_auth_verify_authorizer_reply(struct ceph_auth_client *ac,
struct ceph_authorizer *a, size_t len)
{
if (ac->ops && ac->ops->verify_authorizer_reply)
return ac->ops->verify_authorizer_reply(ac, a, len);
return 0;
}
EXPORT_SYMBOL(ceph_auth_verify_authorizer_reply);
void ceph_auth_invalidate_authorizer(struct ceph_auth_client *ac, int peer_type)
{
if (ac->ops && ac->ops->invalidate_authorizer)
ac->ops->invalidate_authorizer(ac, peer_type);
}
EXPORT_SYMBOL(ceph_auth_invalidate_authorizer);

1
net/ceph/auth_x.c
View File

@ -562,7 +562,6 @@ static int ceph_x_update_authorizer(
{ {
struct ceph_x_authorizer *au; struct ceph_x_authorizer *au;
struct ceph_x_ticket_handler *th; struct ceph_x_ticket_handler *th;
int ret;
th = get_ticket_handler(ac, peer_type); th = get_ticket_handler(ac, peer_type);
if (IS_ERR(th)) if (IS_ERR(th))

7
net/ceph/mon_client.c
View File

@ -737,7 +737,7 @@ static void delayed_work(struct work_struct *work)
__validate_auth(monc); __validate_auth(monc);
if (monc->auth->ops->is_authenticated(monc->auth)) if (ceph_auth_is_authenticated(monc->auth))
__send_subscribe(monc); __send_subscribe(monc);
} }
__schedule_delayed(monc); __schedule_delayed(monc);
@ -892,8 +892,7 @@ static void handle_auth_reply(struct ceph_mon_client *monc,
mutex_lock(&monc->mutex); mutex_lock(&monc->mutex);
had_debugfs_info = have_debugfs_info(monc); had_debugfs_info = have_debugfs_info(monc);
if (monc->auth->ops) was_auth = ceph_auth_is_authenticated(monc->auth);
was_auth = monc->auth->ops->is_authenticated(monc->auth);
monc->pending_auth = 0; monc->pending_auth = 0;
ret = ceph_handle_auth_reply(monc->auth, msg->front.iov_base, ret = ceph_handle_auth_reply(monc->auth, msg->front.iov_base,
msg->front.iov_len, msg->front.iov_len,
@ -904,7 +903,7 @@ static void handle_auth_reply(struct ceph_mon_client *monc,
wake_up_all(&monc->client->auth_wq); wake_up_all(&monc->client->auth_wq);
} else if (ret > 0) { } else if (ret > 0) {
__send_prepared_auth_request(monc, ret); __send_prepared_auth_request(monc, ret);
} else if (!was_auth && monc->auth->ops->is_authenticated(monc->auth)) { } else if (!was_auth && ceph_auth_is_authenticated(monc->auth)) {
dout("authenticated, starting session\n"); dout("authenticated, starting session\n");
monc->client->msgr.inst.name.type = CEPH_ENTITY_TYPE_CLIENT; monc->client->msgr.inst.name.type = CEPH_ENTITY_TYPE_CLIENT;

26
net/ceph/osd_client.c
View File

@ -666,8 +666,7 @@ static void put_osd(struct ceph_osd *osd)
if (atomic_dec_and_test(&osd->o_ref) && osd->o_auth.authorizer) { if (atomic_dec_and_test(&osd->o_ref) && osd->o_auth.authorizer) {
struct ceph_auth_client *ac = osd->o_osdc->client->monc.auth; struct ceph_auth_client *ac = osd->o_osdc->client->monc.auth;
if (ac->ops && ac->ops->destroy_authorizer) ceph_auth_destroy_authorizer(ac, osd->o_auth.authorizer);
ac->ops->destroy_authorizer(ac, osd->o_auth.authorizer);
kfree(osd); kfree(osd);
} }
} }
@ -2211,17 +2210,16 @@ static struct ceph_auth_handshake *get_authorizer(struct ceph_connection *con,
struct ceph_auth_handshake *auth = &o->o_auth; struct ceph_auth_handshake *auth = &o->o_auth;
if (force_new && auth->authorizer) { if (force_new && auth->authorizer) {
if (ac->ops && ac->ops->destroy_authorizer) ceph_auth_destroy_authorizer(ac, auth->authorizer);
ac->ops->destroy_authorizer(ac, auth->authorizer);
auth->authorizer = NULL; auth->authorizer = NULL;
} }
if (!auth->authorizer && ac->ops && ac->ops->create_authorizer) { if (!auth->authorizer) {
int ret = ac->ops->create_authorizer(ac, CEPH_ENTITY_TYPE_OSD, int ret = ceph_auth_create_authorizer(ac, CEPH_ENTITY_TYPE_OSD,
auth); auth);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
} else if (ac->ops && ac->ops->update_authorizer) { } else {
int ret = ac->ops->update_authorizer(ac, CEPH_ENTITY_TYPE_OSD, int ret = ceph_auth_update_authorizer(ac, CEPH_ENTITY_TYPE_OSD,
auth); auth);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
@ -2238,11 +2236,7 @@ static int verify_authorizer_reply(struct ceph_connection *con, int len)
struct ceph_osd_client *osdc = o->o_osdc; struct ceph_osd_client *osdc = o->o_osdc;
struct ceph_auth_client *ac = osdc->client->monc.auth; struct ceph_auth_client *ac = osdc->client->monc.auth;
/* return ceph_auth_verify_authorizer_reply(ac, o->o_auth.authorizer, len);
* XXX If ac->ops or ac->ops->verify_authorizer_reply is null,
* XXX which do we do: succeed or fail?
*/
return ac->ops->verify_authorizer_reply(ac, o->o_auth.authorizer, len);
} }
static int invalidate_authorizer(struct ceph_connection *con) static int invalidate_authorizer(struct ceph_connection *con)
@ -2251,9 +2245,7 @@ static int invalidate_authorizer(struct ceph_connection *con)
struct ceph_osd_client *osdc = o->o_osdc; struct ceph_osd_client *osdc = o->o_osdc;
struct ceph_auth_client *ac = osdc->client->monc.auth; struct ceph_auth_client *ac = osdc->client->monc.auth;
if (ac->ops && ac->ops->invalidate_authorizer) ceph_auth_invalidate_authorizer(ac, CEPH_ENTITY_TYPE_OSD);
ac->ops->invalidate_authorizer(ac, CEPH_ENTITY_TYPE_OSD);
return ceph_monc_validate_auth(&osdc->client->monc); return ceph_monc_validate_auth(&osdc->client->monc);
} }