X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fllog_client.c;h=6b07ef204dcf15236cd8bc31d4331cacbcaca32e;hb=2d617260aaa5f778ab8dcb006e2a827f4b8f8567;hp=aa9107ae14f7bf67bed48ff4b28de86c704a0965;hpb=7bb892f4f3de837a940d867b97fe14013ad67dc6;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/llog_client.c b/lustre/ptlrpc/llog_client.c index aa9107a..6b07ef2 100644 --- a/lustre/ptlrpc/llog_client.c +++ b/lustre/ptlrpc/llog_client.c @@ -1,250 +1,319 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * Copyright (C) 2001-2004 Cluster File Systems, Inc. - * Author: Andreas Dilger + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. * - * remote api for llog - client side + * GPL HEADER END + */ +/* + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + * + * Copyright (c) 2012, Whamcloud, Inc. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/ptlrpc/llog_client.c * + * remote api for llog - client side + * + * Author: Andreas Dilger */ #define DEBUG_SUBSYSTEM S_LOG -#ifndef EXPORT_SYMTAB -#define EXPORT_SYMTAB -#endif - #ifdef __KERNEL__ -#include +#include #else #include #endif -#include -#include -#include -#include +#include +#include +#include +#include + +#define LLOG_CLIENT_ENTRY(ctxt, imp) do { \ + cfs_mutex_lock(&ctxt->loc_mutex); \ + if (ctxt->loc_imp) { \ + imp = class_import_get(ctxt->loc_imp); \ + } else { \ + CERROR("ctxt->loc_imp == NULL for context idx %d." \ + "Unable to complete MDS/OSS recovery," \ + "but I'll try again next time. Not fatal.\n", \ + ctxt->loc_idx); \ + imp = NULL; \ + cfs_mutex_unlock(&ctxt->loc_mutex); \ + return (-EINVAL); \ + } \ + cfs_mutex_unlock(&ctxt->loc_mutex); \ +} while(0) + +#define LLOG_CLIENT_EXIT(ctxt, imp) do { \ + cfs_mutex_lock(&ctxt->loc_mutex); \ + if (ctxt->loc_imp != imp) \ + CWARN("loc_imp has changed from %p to %p\n", \ + ctxt->loc_imp, imp); \ + class_import_put(imp); \ + cfs_mutex_unlock(&ctxt->loc_mutex); \ +} while(0) /* This is a callback from the llog_* functions. * Assumes caller has already pushed us into the kernel context. */ -static int llog_client_open(struct llog_ctxt *ctxt, struct llog_handle **res, - struct llog_logid *logid, char *name, int flags) +static int llog_client_create(const struct lu_env *env, struct llog_ctxt *ctxt, + struct llog_handle **res, + struct llog_logid *logid, char *name) { - struct obd_import *imp; - struct llogd_body req_body; - struct llogd_body *body; - struct llog_handle *handle; + struct obd_import *imp; + struct llogd_body *body; + struct llog_handle *handle; struct ptlrpc_request *req = NULL; - int size[2] = {sizeof(req_body)}; - char *tmp[2] = {(char*) &req_body}; - int bufcount = 1, repsize[] = {sizeof (req_body)}, rc; + int rc; ENTRY; - LASSERT(ctxt->loc_imp); - imp = ctxt->loc_imp; + LLOG_CLIENT_ENTRY(ctxt, imp); handle = llog_alloc_handle(); if (handle == NULL) RETURN(-ENOMEM); *res = handle; - memset(&req_body, 0, sizeof(req_body)); + req = ptlrpc_request_alloc(imp, &RQF_LLOG_ORIGIN_HANDLE_CREATE); + if (req == NULL) + GOTO(err_free, rc = -ENOMEM); + + if (name) + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + strlen(name) + 1); + + rc = ptlrpc_request_pack(req, LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_CREATE); + if (rc) { + ptlrpc_request_free(req); + req = NULL; + GOTO(err_free, rc); + } + ptlrpc_request_set_replen(req); + + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (logid) - req_body.lgd_logid = *logid; - req_body.lgd_ctxt_idx = ctxt->loc_idx - 1; - req_body.lgd_llh_flags = flags; + body->lgd_logid = *logid; + body->lgd_ctxt_idx = ctxt->loc_idx - 1; if (name) { - size[bufcount] = strlen(name) + 1; - tmp[bufcount] = name; - bufcount++; + char *tmp; + tmp = req_capsule_client_sized_get(&req->rq_pill, &RMF_NAME, + strlen(name) + 1); + LASSERT(tmp); + strcpy(tmp, name); } - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, LLOG_ORIGIN_HANDLE_OPEN, - bufcount, size,tmp); - if (!req) - GOTO(err_free, rc = -ENOMEM); - - req->rq_replen = lustre_msg_size(1, repsize); rc = ptlrpc_queue_wait(req); if (rc) GOTO(err_free, rc); - body = lustre_swab_repbuf(req, 0, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(err_free, rc =-EFAULT); - } handle->lgh_id = body->lgd_logid; handle->lgh_ctxt = ctxt; - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); - + LLOG_CLIENT_EXIT(ctxt, imp); + ptlrpc_req_finished(req); + return rc; err_free: + *res = NULL; llog_free_handle(handle); goto out; } -static int llog_client_prev_block(struct llog_handle *loghandle, - int prev_idx, void *buf, int len) +static int llog_client_destroy(const struct lu_env *env, + struct llog_handle *loghandle) +{ + struct obd_import *imp; + struct ptlrpc_request *req = NULL; + struct llogd_body *body; + int rc; + ENTRY; + + LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); + req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_DESTROY, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_DESTROY); + if (req == NULL) + GOTO(err_exit, rc =-ENOMEM); + + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + body->lgd_logid = loghandle->lgh_id; + body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; + + ptlrpc_request_set_replen(req); + rc = ptlrpc_queue_wait(req); + + ptlrpc_req_finished(req); +err_exit: + LLOG_CLIENT_EXIT(loghandle->lgh_ctxt, imp); + RETURN(rc); +} + + +static int llog_client_next_block(const struct lu_env *env, + struct llog_handle *loghandle, + int *cur_idx, int next_idx, + __u64 *cur_offset, void *buf, int len) { - struct obd_import *imp = loghandle->lgh_ctxt->loc_imp; + struct obd_import *imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - void * ptr; - int size = sizeof(*body); - int repsize[2] = {sizeof (*body)}; - int rc; + struct llogd_body *body; + void *ptr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_PREV_BLOCK, 1, &size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); + req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_NEXT_BLOCK); + if (req == NULL) + GOTO(err_exit, rc =-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, 0, sizeof (*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; - body->lgd_index = prev_idx; + body->lgd_index = next_idx; + body->lgd_saved_index = *cur_idx; body->lgd_len = len; - repsize[1] = len; + body->lgd_cur_offset = *cur_offset; - req->rq_replen = lustre_msg_size(2, repsize); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, 0, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } - ptr = lustre_msg_buf(req->rq_repmsg, 1, len); - if (ptr == NULL) { - CERROR ("Can't unpack bitmap\n"); + /* The log records are swabbed as they are processed */ + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); + if (ptr == NULL) GOTO(out, rc =-EFAULT); - } + + *cur_idx = body->lgd_saved_index; + *cur_offset = body->lgd_cur_offset; memcpy(buf, ptr, len); + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); +err_exit: + LLOG_CLIENT_EXIT(loghandle->lgh_ctxt, imp); + return rc; } -static int llog_client_next_block(struct llog_handle *loghandle, - int *cur_idx, int next_idx, - __u64 *cur_offset, void *buf, int len) +static int llog_client_prev_block(const struct lu_env *env, + struct llog_handle *loghandle, + int prev_idx, void *buf, int len) { - struct obd_import *imp = loghandle->lgh_ctxt->loc_imp; + struct obd_import *imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - void * ptr; - int size = sizeof(*body); - int repsize[2] = {sizeof (*body)}; - int rc; + struct llogd_body *body; + void *ptr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_NEXT_BLOCK, 1, &size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); + req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_PREV_BLOCK); + if (req == NULL) + GOTO(err_exit, rc = -ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, 0, sizeof (*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; - body->lgd_index = next_idx; - body->lgd_saved_index = *cur_idx; + body->lgd_index = prev_idx; body->lgd_len = len; - body->lgd_cur_offset = *cur_offset; - repsize[1] = len; - req->rq_replen = lustre_msg_size(2, repsize); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len); + ptlrpc_request_set_replen(req); + rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, 0, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } - ptr = lustre_msg_buf(req->rq_repmsg, 1, len); - if (ptr == NULL) { - CERROR ("Can't unpack bitmap\n"); + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); + if (ptr == NULL) GOTO(out, rc =-EFAULT); - } - - *cur_idx = body->lgd_saved_index; - *cur_offset = body->lgd_cur_offset; memcpy(buf, ptr, len); - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); +err_exit: + LLOG_CLIENT_EXIT(loghandle->lgh_ctxt, imp); + return rc; } - -static int llog_client_read_header(struct llog_handle *handle) +static int llog_client_read_header(const struct lu_env *env, + struct llog_handle *handle) { - struct obd_import *imp = handle->lgh_ctxt->loc_imp; + struct obd_import *imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - struct llog_log_hdr *hdr; - struct llog_rec_hdr *llh_hdr; - int size = sizeof(*body); - int repsize = sizeof (*hdr); - int rc; + struct llogd_body *body; + struct llog_log_hdr *hdr; + struct llog_rec_hdr *llh_hdr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_READ_HEADER, 1, &size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + LLOG_CLIENT_ENTRY(handle->lgh_ctxt, imp); + req = ptlrpc_request_alloc_pack(imp,&RQF_LLOG_ORIGIN_HANDLE_READ_HEADER, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_READ_HEADER); + if (req == NULL) + GOTO(err_exit, rc = -ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, 0, sizeof (*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = handle->lgh_id; body->lgd_ctxt_idx = handle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = handle->lgh_hdr->llh_flags; - req->rq_replen = lustre_msg_size(1, &repsize); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - hdr = lustre_swab_repbuf(req, 0, sizeof(*hdr), lustre_swab_llog_hdr); - if (hdr == NULL) { - CERROR ("Can't unpack llog_hdr\n"); + hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR); + if (hdr == NULL) GOTO(out, rc =-EFAULT); - } memcpy(handle->lgh_hdr, hdr, sizeof (*hdr)); handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index; @@ -262,25 +331,30 @@ static int llog_client_read_header(struct llog_handle *handle) CERROR("you may need to re-run lconf --write_conf.\n"); rc = -EIO; } - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); +err_exit: + LLOG_CLIENT_EXIT(handle->lgh_ctxt, imp); + return rc; } -static int llog_client_close(struct llog_handle *handle) +static int llog_client_close(const struct lu_env *env, + struct llog_handle *handle) { - int rc = 0; - - RETURN(rc); + /* this doesn't call LLOG_ORIGIN_HANDLE_CLOSE because + the servers all close the file at the end of every + other LLOG_ RPC. */ + return(0); } struct llog_operations llog_client_ops = { - lop_prev_block: llog_client_prev_block, lop_next_block: llog_client_next_block, + lop_prev_block: llog_client_prev_block, lop_read_header: llog_client_read_header, - lop_open: llog_client_open, + lop_create: llog_client_create, + lop_destroy: llog_client_destroy, lop_close: llog_client_close, }; +EXPORT_SYMBOL(llog_client_ops);