4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2015, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
32 * lustre/ptlrpc/llog_server.c
34 * remote api for llog - server side
36 * Author: Andreas Dilger <adilger@clusterfs.com>
39 #define DEBUG_SUBSYSTEM S_LOG
41 #include <obd_class.h>
42 #include <lu_target.h>
43 #include <lustre_log.h>
44 #include <lustre_net.h>
46 static int llog_origin_close(const struct lu_env *env, struct llog_handle *lgh)
48 if (lgh->lgh_hdr != NULL && lgh->lgh_hdr->llh_flags & LLOG_F_IS_CAT)
49 return llog_cat_close(env, lgh);
51 return llog_close(env, lgh);
54 /* Only open is supported, no new llog can be created remotely */
55 int llog_origin_handle_open(struct ptlrpc_request *req)
57 struct obd_export *exp = req->rq_export;
58 struct obd_device *obd = exp->exp_obd;
59 struct llog_handle *loghandle;
60 struct llogd_body *body;
61 struct llog_logid *logid = NULL;
62 struct llog_ctxt *ctxt;
68 body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
70 RETURN(err_serious(-EFAULT));
72 rc = req_capsule_server_pack(&req->rq_pill);
74 RETURN(err_serious(-ENOMEM));
76 if (ostid_id(&body->lgd_logid.lgl_oi) > 0)
77 logid = &body->lgd_logid;
79 if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) {
80 name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
83 CDEBUG(D_INFO, "%s: opening log %s\n", obd->obd_name, name);
86 if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
87 CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d name=%s\n",
88 obd->obd_name, body->lgd_ctxt_idx, name);
92 ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
94 CDEBUG(D_WARNING, "%s: no ctxt. group=%p idx=%d name=%s\n",
95 obd->obd_name, &obd->obd_olg, body->lgd_ctxt_idx, name);
99 rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle, logid,
100 name, LLOG_OPEN_EXISTS);
104 body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
105 body->lgd_logid = loghandle->lgh_id;
107 llog_origin_close(req->rq_svc_thread->t_env, loghandle);
114 int llog_origin_handle_destroy(struct ptlrpc_request *req)
116 struct llogd_body *body;
117 struct llog_logid *logid = NULL;
118 struct llog_ctxt *ctxt;
123 body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
125 RETURN(err_serious(-EFAULT));
127 rc = req_capsule_server_pack(&req->rq_pill);
129 RETURN(err_serious(-ENOMEM));
131 if (ostid_id(&body->lgd_logid.lgl_oi) > 0)
132 logid = &body->lgd_logid;
134 if (!(body->lgd_llh_flags & LLOG_F_IS_PLAIN))
135 CERROR("%s: wrong llog flags %x\n",
136 req->rq_export->exp_obd->obd_name, body->lgd_llh_flags);
138 if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
139 CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
140 req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
144 ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
148 rc = llog_erase(req->rq_svc_thread->t_env, ctxt, logid, NULL);
153 int llog_origin_handle_next_block(struct ptlrpc_request *req)
155 struct llog_handle *loghandle;
156 struct llogd_body *body;
157 struct llogd_body *repbody;
158 struct llog_ctxt *ctxt;
165 body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
167 RETURN(err_serious(-EFAULT));
169 req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
170 LLOG_MIN_CHUNK_SIZE);
171 rc = req_capsule_server_pack(&req->rq_pill);
173 RETURN(err_serious(-ENOMEM));
175 if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
176 CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
177 req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
181 ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
185 rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
186 &body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
190 flags = body->lgd_llh_flags;
191 rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
196 repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
199 ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
200 rc = llog_next_block(req->rq_svc_thread->t_env, loghandle,
201 &repbody->lgd_saved_index, repbody->lgd_index,
202 &repbody->lgd_cur_offset, ptr,
203 LLOG_MIN_CHUNK_SIZE);
208 llog_origin_close(req->rq_svc_thread->t_env, loghandle);
214 int llog_origin_handle_prev_block(struct ptlrpc_request *req)
216 struct llog_handle *loghandle;
217 struct llogd_body *body;
218 struct llogd_body *repbody;
219 struct llog_ctxt *ctxt;
226 body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
228 RETURN(err_serious(-EFAULT));
230 req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
231 LLOG_MIN_CHUNK_SIZE);
232 rc = req_capsule_server_pack(&req->rq_pill);
234 RETURN(err_serious(-ENOMEM));
236 if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
237 CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
238 req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
242 ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
246 rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
247 &body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
251 flags = body->lgd_llh_flags;
252 rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
257 repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
260 ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
261 rc = llog_prev_block(req->rq_svc_thread->t_env, loghandle,
262 body->lgd_index, ptr, LLOG_MIN_CHUNK_SIZE);
268 llog_origin_close(req->rq_svc_thread->t_env, loghandle);
274 int llog_origin_handle_read_header(struct ptlrpc_request *req)
276 struct llog_handle *loghandle;
277 struct llogd_body *body;
278 struct llog_log_hdr *hdr;
279 struct llog_ctxt *ctxt;
285 body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
287 RETURN(err_serious(-EFAULT));
289 rc = req_capsule_server_pack(&req->rq_pill);
291 RETURN(err_serious(-ENOMEM));
293 if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
294 CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
295 req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
299 ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
303 rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
304 &body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
309 * llog_init_handle() reads the llog header
311 flags = body->lgd_llh_flags;
312 rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
316 flags = loghandle->lgh_hdr->llh_flags;
318 hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
319 *hdr = *loghandle->lgh_hdr;
322 llog_origin_close(req->rq_svc_thread->t_env, loghandle);
328 int llog_origin_handle_close(struct ptlrpc_request *req)
334 rc = req_capsule_server_pack(&req->rq_pill);
336 RETURN(err_serious(-ENOMEM));