Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 | /*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*
* 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).
*
* 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
*
* 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.
*
* GPL HEADER END
*/
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/include/lustre_log.h
*
* Generic infrastructure for managing a collection of logs.
* These logs are used for:
*
* - orphan recovery: OST adds record on create
* - mtime/size consistency: the OST adds a record on first write
* - open/unlinked objects: OST adds a record on destroy
*
* - mds unlink log: the MDS adds an entry upon delete
*
* - raid1 replication log between OST's
* - MDS replication logs
*/
#ifndef _LUSTRE_LOG_H
#define _LUSTRE_LOG_H
/** \defgroup log log
*
* @{
*/
#include <linux/lustre_log.h>
#include <obd_class.h>
#include <obd_ost.h>
#include <lustre/lustre_idl.h>
#include <dt_object.h>
#define LOG_NAME_LIMIT(logname, name) \
snprintf(logname, sizeof(logname), "LOGS/%s", name)
#define LLOG_EEMPTY 4711
enum llog_open_param {
LLOG_OPEN_EXISTS = 0x0000,
LLOG_OPEN_NEW = 0x0001,
};
struct plain_handle_data {
struct list_head phd_entry;
struct llog_handle *phd_cat_handle;
struct llog_cookie phd_cookie; /* cookie of this log in its cat */
};
struct cat_handle_data {
struct list_head chd_head;
struct llog_handle *chd_current_log; /* currently open log */
struct llog_handle *chd_next_log; /* llog to be used next */
};
static inline void logid_to_fid(struct llog_logid *id, struct lu_fid *fid)
{
/* For compatibility purposes we identify pre-OSD (~< 2.3.51 MDS)
* logid's by non-zero ogen (inode generation) and convert them
* into IGIF */
if (id->lgl_ogen == 0) {
fid->f_seq = id->lgl_oi.oi.oi_seq;
fid->f_oid = id->lgl_oi.oi.oi_id;
fid->f_ver = 0;
} else {
lu_igif_build(fid, id->lgl_oi.oi.oi_id, id->lgl_ogen);
}
}
static inline void fid_to_logid(struct lu_fid *fid, struct llog_logid *id)
{
id->lgl_oi.oi.oi_seq = fid->f_seq;
id->lgl_oi.oi.oi_id = fid->f_oid;
id->lgl_ogen = 0;
}
static inline void logid_set_id(struct llog_logid *log_id, __u64 id)
{
log_id->lgl_oi.oi.oi_id = id;
}
static inline __u64 logid_id(struct llog_logid *log_id)
{
return log_id->lgl_oi.oi.oi_id;
}
struct llog_handle;
/* llog.c - general API */
int llog_init_handle(const struct lu_env *env, struct llog_handle *handle,
int flags, struct obd_uuid *uuid);
int llog_copy_handler(const struct lu_env *env, struct llog_handle *llh,
struct llog_rec_hdr *rec, void *data);
int llog_process(const struct lu_env *env, struct llog_handle *loghandle,
llog_cb_t cb, void *data, void *catdata);
int llog_process_or_fork(const struct lu_env *env,
struct llog_handle *loghandle,
llog_cb_t cb, void *data, void *catdata, bool fork);
int llog_reverse_process(const struct lu_env *env,
struct llog_handle *loghandle, llog_cb_t cb,
void *data, void *catdata);
int llog_cancel_rec(const struct lu_env *env, struct llog_handle *loghandle,
int index);
int llog_open(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_handle **lgh, struct llog_logid *logid,
char *name, enum llog_open_param open_param);
int llog_close(const struct lu_env *env, struct llog_handle *cathandle);
int llog_is_empty(const struct lu_env *env, struct llog_ctxt *ctxt,
char *name);
int llog_backup(const struct lu_env *env, struct obd_device *obd,
struct llog_ctxt *ctxt, struct llog_ctxt *bak_ctxt,
char *name, char *backup);
/* llog_process flags */
#define LLOG_FLAG_NODEAMON 0x0001
/* llog_cat.c - catalog api */
struct llog_process_data {
/**
* Any useful data needed while processing catalog. This is
* passed later to process callback.
*/
void *lpd_data;
/**
* Catalog process callback function, called for each record
* in catalog.
*/
llog_cb_t lpd_cb;
/**
* Start processing the catalog from startcat/startidx
*/
int lpd_startcat;
int lpd_startidx;
};
struct llog_process_cat_data {
/**
* Temporary stored first_idx while scanning log.
*/
int lpcd_first_idx;
/**
* Temporary stored last_idx while scanning log.
*/
int lpcd_last_idx;
};
int llog_cat_close(const struct lu_env *env, struct llog_handle *cathandle);
int llog_cat_add_rec(const struct lu_env *env, struct llog_handle *cathandle,
struct llog_rec_hdr *rec, struct llog_cookie *reccookie,
void *buf, struct thandle *th);
int llog_cat_declare_add_rec(const struct lu_env *env,
struct llog_handle *cathandle,
struct llog_rec_hdr *rec, struct thandle *th);
int llog_cat_add(const struct lu_env *env, struct llog_handle *cathandle,
struct llog_rec_hdr *rec, struct llog_cookie *reccookie,
void *buf);
int llog_cat_cancel_records(const struct lu_env *env,
struct llog_handle *cathandle, int count,
struct llog_cookie *cookies);
int llog_cat_process_or_fork(const struct lu_env *env,
struct llog_handle *cat_llh, llog_cb_t cb,
void *data, int startcat, int startidx, bool fork);
int llog_cat_process(const struct lu_env *env, struct llog_handle *cat_llh,
llog_cb_t cb, void *data, int startcat, int startidx);
int llog_cat_reverse_process(const struct lu_env *env,
struct llog_handle *cat_llh, llog_cb_t cb,
void *data);
int llog_cat_init_and_process(const struct lu_env *env,
struct llog_handle *llh);
/* llog_obd.c */
int llog_setup(const struct lu_env *env, struct obd_device *obd,
struct obd_llog_group *olg, int index,
struct obd_device *disk_obd, struct llog_operations *op);
int __llog_ctxt_put(const struct lu_env *env, struct llog_ctxt *ctxt);
int llog_cleanup(const struct lu_env *env, struct llog_ctxt *);
int llog_sync(struct llog_ctxt *ctxt, struct obd_export *exp, int flags);
int llog_obd_add(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_rec_hdr *rec, struct lov_stripe_md *lsm,
struct llog_cookie *logcookies, int numcookies);
int llog_cancel(const struct lu_env *env, struct llog_ctxt *ctxt,
struct lov_stripe_md *lsm, int count,
struct llog_cookie *cookies, int flags);
int obd_llog_init(struct obd_device *obd, struct obd_llog_group *olg,
struct obd_device *disk_obd, int *idx);
int obd_llog_finish(struct obd_device *obd, int count);
/* llog_ioctl.c */
int llog_ioctl(const struct lu_env *env, struct llog_ctxt *ctxt, int cmd,
struct obd_ioctl_data *data);
/* llog_net.c */
int llog_initiator_connect(struct llog_ctxt *ctxt);
struct llog_operations {
int (*lop_destroy)(const struct lu_env *env,
struct llog_handle *handle);
int (*lop_next_block)(const struct lu_env *env, struct llog_handle *h,
int *curr_idx, int next_idx, __u64 *offset,
void *buf, int len);
int (*lop_prev_block)(const struct lu_env *env, struct llog_handle *h,
int prev_idx, void *buf, int len);
int (*lop_read_header)(const struct lu_env *env,
struct llog_handle *handle);
int (*lop_setup)(const struct lu_env *env, struct obd_device *obd,
struct obd_llog_group *olg, int ctxt_idx,
struct obd_device *disk_obd);
int (*lop_sync)(struct llog_ctxt *ctxt, struct obd_export *exp,
int flags);
int (*lop_cleanup)(const struct lu_env *env, struct llog_ctxt *ctxt);
int (*lop_cancel)(const struct lu_env *env, struct llog_ctxt *ctxt,
struct lov_stripe_md *lsm, int count,
struct llog_cookie *cookies, int flags);
int (*lop_connect)(struct llog_ctxt *ctxt, struct llog_logid *logid,
struct llog_gen *gen, struct obd_uuid *uuid);
/**
* Any llog file must be opened first using llog_open(). Llog can be
* opened by name, logid or without both, in last case the new logid
* will be generated.
*/
int (*lop_open)(const struct lu_env *env, struct llog_handle *lgh,
struct llog_logid *logid, char *name,
enum llog_open_param);
/**
* Opened llog may not exist and this must be checked where needed using
* the llog_exist() call.
*/
int (*lop_exist)(struct llog_handle *lgh);
/**
* Close llog file and calls llog_free_handle() implicitly.
* Any opened llog must be closed by llog_close() call.
*/
int (*lop_close)(const struct lu_env *env, struct llog_handle *handle);
/**
* Create new llog file. The llog must be opened.
* Must be used only for local llog operations.
*/
int (*lop_declare_create)(const struct lu_env *env,
struct llog_handle *handle,
struct thandle *th);
int (*lop_create)(const struct lu_env *env, struct llog_handle *handle,
struct thandle *th);
/**
* write new record in llog. It appends records usually but can edit
* existing records too.
*/
int (*lop_declare_write_rec)(const struct lu_env *env,
struct llog_handle *lgh,
struct llog_rec_hdr *rec,
int idx, struct thandle *th);
int (*lop_write_rec)(const struct lu_env *env,
struct llog_handle *loghandle,
struct llog_rec_hdr *rec,
struct llog_cookie *cookie, int cookiecount,
void *buf, int idx, struct thandle *th);
/**
* Add new record in llog catalog. Does the same as llog_write_rec()
* but using llog catalog.
*/
int (*lop_declare_add)(const struct lu_env *env,
struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct thandle *th);
int (*lop_add)(const struct lu_env *env, struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct llog_cookie *cookie,
void *buf, struct thandle *th);
/* Old llog_add version, used in MDS-LOV-OSC now and will gone with
* LOD/OSP replacement */
int (*lop_obd_add)(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_rec_hdr *rec, struct lov_stripe_md *lsm,
struct llog_cookie *logcookies, int numcookies);
};
/* In-memory descriptor for a log object or log catalog */
struct llog_handle {
struct rw_semaphore lgh_lock;
spinlock_t lgh_hdr_lock; /* protect lgh_hdr data */
struct llog_logid lgh_id; /* id of this log */
struct llog_log_hdr *lgh_hdr;
struct file *lgh_file;
struct dt_object *lgh_obj;
int lgh_last_idx;
int lgh_cur_idx; /* used during llog_process */
__u64 lgh_cur_offset; /* used during llog_process */
struct llog_ctxt *lgh_ctxt;
union {
struct plain_handle_data phd;
struct cat_handle_data chd;
} u;
char *lgh_name;
void *private_data;
struct llog_operations *lgh_logops;
atomic_t lgh_refcount;
};
/* llog_lvfs.c */
extern struct llog_operations llog_lvfs_ops;
/* llog_osd.c */
extern struct llog_operations llog_osd_ops;
int llog_osd_get_cat_list(const struct lu_env *env, struct dt_device *d,
int idx, int count,
struct llog_catid *idarray);
int llog_osd_put_cat_list(const struct lu_env *env, struct dt_device *d,
int idx, int count,
struct llog_catid *idarray);
#define LLOG_CTXT_FLAG_UNINITIALIZED 0x00000001
#define LLOG_CTXT_FLAG_STOP 0x00000002
struct llog_ctxt {
int loc_idx; /* my index the obd array of ctxt's */
struct obd_device *loc_obd; /* points back to the containing obd*/
struct obd_llog_group *loc_olg; /* group containing that ctxt */
struct obd_export *loc_exp; /* parent "disk" export (e.g. MDS) */
struct obd_import *loc_imp; /* to use in RPC's: can be backward
pointing import */
struct llog_operations *loc_logops;
struct llog_handle *loc_handle;
struct mutex loc_mutex; /* protect loc_imp */
atomic_t loc_refcount;
long loc_flags; /* flags, see above defines */
struct dt_object *loc_dir;
};
#define LLOG_PROC_BREAK 0x0001
#define LLOG_DEL_RECORD 0x0002
static inline int llog_obd2ops(struct llog_ctxt *ctxt,
struct llog_operations **lop)
{
if (ctxt == NULL)
return -ENOTCONN;
*lop = ctxt->loc_logops;
if (*lop == NULL)
return -EOPNOTSUPP;
return 0;
}
static inline int llog_handle2ops(struct llog_handle *loghandle,
struct llog_operations **lop)
{
if (loghandle == NULL || loghandle->lgh_logops == NULL)
return -EINVAL;
*lop = loghandle->lgh_logops;
return 0;
}
static inline int llog_data_len(int len)
{
return cfs_size_round(len);
}
static inline int llog_get_size(struct llog_handle *loghandle)
{
if (loghandle && loghandle->lgh_hdr)
return loghandle->lgh_hdr->llh_count;
return 0;
}
static inline struct llog_ctxt *llog_ctxt_get(struct llog_ctxt *ctxt)
{
atomic_inc(&ctxt->loc_refcount);
CDEBUG(D_INFO, "GETting ctxt %p : new refcount %d\n", ctxt,
atomic_read(&ctxt->loc_refcount));
return ctxt;
}
static inline void llog_ctxt_put(struct llog_ctxt *ctxt)
{
if (ctxt == NULL)
return;
LASSERT_ATOMIC_GT_LT(&ctxt->loc_refcount, 0, LI_POISON);
CDEBUG(D_INFO, "PUTting ctxt %p : new refcount %d\n", ctxt,
atomic_read(&ctxt->loc_refcount) - 1);
__llog_ctxt_put(NULL, ctxt);
}
static inline void llog_group_init(struct obd_llog_group *olg, int group)
{
init_waitqueue_head(&olg->olg_waitq);
spin_lock_init(&olg->olg_lock);
mutex_init(&olg->olg_cat_processing);
olg->olg_seq = group;
}
static inline int llog_group_set_ctxt(struct obd_llog_group *olg,
struct llog_ctxt *ctxt, int index)
{
LASSERT(index >= 0 && index < LLOG_MAX_CTXTS);
spin_lock(&olg->olg_lock);
if (olg->olg_ctxts[index] != NULL) {
spin_unlock(&olg->olg_lock);
return -EEXIST;
}
olg->olg_ctxts[index] = ctxt;
spin_unlock(&olg->olg_lock);
return 0;
}
static inline struct llog_ctxt *llog_group_get_ctxt(struct obd_llog_group *olg,
int index)
{
struct llog_ctxt *ctxt;
LASSERT(index >= 0 && index < LLOG_MAX_CTXTS);
spin_lock(&olg->olg_lock);
if (olg->olg_ctxts[index] == NULL)
ctxt = NULL;
else
ctxt = llog_ctxt_get(olg->olg_ctxts[index]);
spin_unlock(&olg->olg_lock);
return ctxt;
}
static inline void llog_group_clear_ctxt(struct obd_llog_group *olg, int index)
{
LASSERT(index >= 0 && index < LLOG_MAX_CTXTS);
spin_lock(&olg->olg_lock);
olg->olg_ctxts[index] = NULL;
spin_unlock(&olg->olg_lock);
}
static inline struct llog_ctxt *llog_get_context(struct obd_device *obd,
int index)
{
return llog_group_get_ctxt(&obd->obd_olg, index);
}
static inline int llog_group_ctxt_null(struct obd_llog_group *olg, int index)
{
return (olg->olg_ctxts[index] == NULL);
}
static inline int llog_ctxt_null(struct obd_device *obd, int index)
{
return (llog_group_ctxt_null(&obd->obd_olg, index));
}
static inline int llog_destroy(const struct lu_env *env,
struct llog_handle *handle)
{
struct llog_operations *lop;
int rc;
rc = llog_handle2ops(handle, &lop);
if (rc)
return rc;
if (lop->lop_destroy == NULL)
return -EOPNOTSUPP;
rc = lop->lop_destroy(env, handle);
return rc;
}
static inline int llog_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 llog_operations *lop;
int rc;
rc = llog_handle2ops(loghandle, &lop);
if (rc)
return rc;
if (lop->lop_next_block == NULL)
return -EOPNOTSUPP;
rc = lop->lop_next_block(env, loghandle, cur_idx, next_idx,
cur_offset, buf, len);
return rc;
}
static inline int llog_prev_block(const struct lu_env *env,
struct llog_handle *loghandle,
int prev_idx, void *buf, int len)
{
struct llog_operations *lop;
int rc;
rc = llog_handle2ops(loghandle, &lop);
if (rc)
return rc;
if (lop->lop_prev_block == NULL)
return -EOPNOTSUPP;
rc = lop->lop_prev_block(env, loghandle, prev_idx, buf, len);
return rc;
}
static inline int llog_connect(struct llog_ctxt *ctxt,
struct llog_logid *logid, struct llog_gen *gen,
struct obd_uuid *uuid)
{
struct llog_operations *lop;
int rc;
rc = llog_obd2ops(ctxt, &lop);
if (rc)
return rc;
if (lop->lop_connect == NULL)
return -EOPNOTSUPP;
rc = lop->lop_connect(ctxt, logid, gen, uuid);
return rc;
}
/* llog.c */
int llog_exist(struct llog_handle *loghandle);
int llog_declare_create(const struct lu_env *env,
struct llog_handle *loghandle, struct thandle *th);
int llog_create(const struct lu_env *env, struct llog_handle *handle,
struct thandle *th);
int llog_declare_write_rec(const struct lu_env *env,
struct llog_handle *handle,
struct llog_rec_hdr *rec, int idx,
struct thandle *th);
int llog_write_rec(const struct lu_env *env, struct llog_handle *handle,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
int numcookies, void *buf, int idx, struct thandle *th);
int llog_add(const struct lu_env *env, struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
void *buf, struct thandle *th);
int llog_declare_add(const struct lu_env *env, struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct thandle *th);
int lustre_process_log(struct super_block *sb, char *logname,
struct config_llog_instance *cfg);
int lustre_end_log(struct super_block *sb, char *logname,
struct config_llog_instance *cfg);
int llog_open_create(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_handle **res, struct llog_logid *logid,
char *name);
int llog_erase(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_logid *logid, char *name);
int llog_write(const struct lu_env *env, struct llog_handle *loghandle,
struct llog_rec_hdr *rec, struct llog_cookie *reccookie,
int cookiecount, void *buf, int idx);
/** @} log */
#endif
|