lustre/include/lustre_log.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2001 Cluster File Systems, Inc. <info@clusterfs.com>
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * Generic infrastructure for managing a collection of logs.
  22  *
  23  * These logs are used for:
  24  *
  25  * - orphan recovery: OST adds record on create
  26  * - mtime/size consistency: the OST adds a record on first write
  27  * - open/unlinked objects: OST adds a record on destroy
  28  *
  29  * - mds unlink log: the MDS adds an entry upon delete
  30  *
  31  * - raid1 replication log between OST's
  32  * - MDS replication logs
  33  */
  34
  35 #ifndef _LUSTRE_LOG_H
  36 #define _LUSTRE_LOG_H
  37
  38 #if defined(__linux__)
  39 #include <linux/lustre_log.h>
  40 #elif defined(__APPLE__)
  41 #include <darwin/lustre_log.h>
  42 #elif defined(__WINNT__)
  43 #include <winnt/lustre_log.h>
  44 #else
  45 #error Unsupported operating system.
  46 #endif
  47
  48 #include <obd.h>
  49 #include <obd_ost.h>
  50 #include <lustre/lustre_idl.h>
  51
  52 #define LOG_NAME_LIMIT(logname, name)                   \
  53         snprintf(logname, sizeof(logname), "LOGS/%s", name)
  54 #define LLOG_EEMPTY 4711
  55
  56 struct plain_handle_data {
  57         struct list_head    phd_entry;
  58         struct llog_handle *phd_cat_handle;
  59         struct llog_cookie  phd_cookie; /* cookie of this log in its cat */
  60         int                 phd_last_idx;
  61 };
  62
  63 struct cat_handle_data {
  64         struct list_head        chd_head;
  65         struct llog_handle     *chd_current_log; /* currently open log */
  66 };
  67
  68 /* In-memory descriptor for a log object or log catalog */
  69 struct llog_handle {
  70         struct rw_semaphore     lgh_lock;
  71         struct llog_logid       lgh_id;              /* id of this log */
  72         struct llog_log_hdr    *lgh_hdr;
  73         struct file            *lgh_file;
  74         int                     lgh_last_idx;
  75         int                     lgh_cur_idx;    /* used during llog_process */
  76         __u64                   lgh_cur_offset; /* used during llog_process */
  77         struct llog_ctxt       *lgh_ctxt;
  78         union {
  79                 struct plain_handle_data phd;
  80                 struct cat_handle_data   chd;
  81         } u;
  82 };
  83
  84 /* llog.c  -  general API */
  85 typedef int (*llog_cb_t)(struct llog_handle *, struct llog_rec_hdr *, void *);
  86 typedef int (*llog_fill_rec_cb_t)(struct llog_rec_hdr *rec, void *data);
  87 extern struct llog_handle *llog_alloc_handle(void);
  88 int llog_init_handle(struct llog_handle *handle, int flags,
  89                      struct obd_uuid *uuid);
  90 extern void llog_free_handle(struct llog_handle *handle);
  91 int llog_process(struct llog_handle *loghandle, llog_cb_t cb,
  92                  void *data, void *catdata);
  93 int llog_reverse_process(struct llog_handle *loghandle, llog_cb_t cb,
  94                          void *data, void *catdata);
  95 extern int llog_cancel_rec(struct llog_handle *loghandle, int index);
  96 extern int llog_close(struct llog_handle *cathandle);
  97 extern int llog_get_size(struct llog_handle *loghandle);
  98
  99 /* llog_cat.c   -  catalog api */
 100 struct llog_process_data {
 101         void *lpd_data;
 102         llog_cb_t lpd_cb;
 103 };
 104
 105 struct llog_process_cat_data {
 106         int     first_idx;
 107         int     last_idx;
 108         /* to process catalog across zero record */
 109 };
 110
 111 int llog_cat_put(struct llog_handle *cathandle);
 112 int llog_cat_add_rec(struct llog_handle *cathandle, struct llog_rec_hdr *rec,
 113                      struct llog_cookie *reccookie, void *buf);
 114 int llog_cat_cancel_records(struct llog_handle *cathandle, int count,
 115                             struct llog_cookie *cookies);
 116 int llog_cat_process(struct llog_handle *cat_llh, llog_cb_t cb, void *data);
 117 int llog_cat_reverse_process(struct llog_handle *cat_llh, llog_cb_t cb, void *data);
 118 int llog_cat_set_first_idx(struct llog_handle *cathandle, int index);
 119
 120 /* llog_obd.c */
 121 int llog_setup(struct obd_device *obd, struct obd_llog_group *olg, int index,
 122                struct obd_device *disk_obd, int count,  struct llog_logid *logid,
 123                struct llog_operations *op);
 124 int __llog_ctxt_put(struct llog_ctxt *ctxt);
 125 int llog_cleanup(struct llog_ctxt *);
 126 int llog_sync(struct llog_ctxt *ctxt, struct obd_export *exp);
 127 int llog_add(struct llog_ctxt *ctxt, struct llog_rec_hdr *rec,
 128              struct lov_stripe_md *lsm, struct llog_cookie *logcookies,
 129              int numcookies);
 130 int llog_cancel(struct llog_ctxt *, struct lov_stripe_md *lsm,
 131                 int count, struct llog_cookie *cookies, int flags);
 132
 133 int llog_obd_origin_setup(struct obd_device *obd, struct obd_llog_group *olg,
 134                           int index, struct obd_device *disk_obd, int count,
 135                           struct llog_logid *logid);
 136 int llog_obd_origin_cleanup(struct llog_ctxt *ctxt);
 137 int llog_obd_origin_add(struct llog_ctxt *ctxt,
 138                         struct llog_rec_hdr *rec, struct lov_stripe_md *lsm,
 139                         struct llog_cookie *logcookies, int numcookies);
 140
 141 int llog_cat_initialize(struct obd_device *obd, struct obd_llog_group *olg,
 142                         int count, struct obd_uuid *uuid);
 143 int obd_llog_init(struct obd_device *obd, int group,
 144                   struct obd_device *disk_obd, int count,
 145                   struct llog_catid *logid, struct obd_uuid *uuid);
 146
 147 int obd_llog_finish(struct obd_device *obd, int count);
 148
 149 /* llog_ioctl.c */
 150 int llog_ioctl(struct llog_ctxt *ctxt, int cmd, struct obd_ioctl_data *data);
 151 int llog_catalog_list(struct obd_device *obd, int count,
 152                       struct obd_ioctl_data *data);
 153
 154 /* llog_net.c */
 155 int llog_initiator_connect(struct llog_ctxt *ctxt);
 156 int llog_receptor_accept(struct llog_ctxt *ctxt, struct obd_import *imp);
 157 int llog_origin_connect(struct llog_ctxt *ctxt, int count,
 158                         struct llog_logid *logid, struct llog_gen *gen,
 159                         struct obd_uuid *uuid);
 160 int llog_handle_connect(struct ptlrpc_request *req);
 161
 162 /* recov_thread.c */
 163 int llog_obd_repl_cancel(struct llog_ctxt *ctxt,
 164                          struct lov_stripe_md *lsm, int count,
 165                          struct llog_cookie *cookies, int flags);
 166 int llog_obd_repl_sync(struct llog_ctxt *ctxt, struct obd_export *exp);
 167 int llog_repl_connect(struct llog_ctxt *ctxt, int count,
 168                       struct llog_logid *logid, struct llog_gen *gen,
 169                       struct obd_uuid *uuid);
 170
 171 struct llog_operations {
 172         int (*lop_write_rec)(struct llog_handle *loghandle,
 173                              struct llog_rec_hdr *rec,
 174                              struct llog_cookie *logcookies, int numcookies,
 175                              void *, int idx);
 176         int (*lop_destroy)(struct llog_handle *handle);
 177         int (*lop_next_block)(struct llog_handle *h, int *curr_idx,
 178                               int next_idx, __u64 *offset, void *buf, int len);
 179         int (*lop_prev_block)(struct llog_handle *h,
 180                               int prev_idx, void *buf, int len);
 181         int (*lop_create)(struct llog_ctxt *ctxt, struct llog_handle **,
 182                           struct llog_logid *logid, char *name);
 183         int (*lop_close)(struct llog_handle *handle);
 184         int (*lop_read_header)(struct llog_handle *handle);
 185
 186         int (*lop_setup)(struct obd_device *obd, struct obd_llog_group *olg,
 187                          int ctxt_idx, struct obd_device *disk_obd, int count,
 188                          struct llog_logid *logid);
 189         int (*lop_sync)(struct llog_ctxt *ctxt, struct obd_export *exp);
 190         int (*lop_cleanup)(struct llog_ctxt *ctxt);
 191         int (*lop_add)(struct llog_ctxt *ctxt, struct llog_rec_hdr *rec,
 192                        struct lov_stripe_md *lsm,
 193                        struct llog_cookie *logcookies, int numcookies);
 194         int (*lop_cancel)(struct llog_ctxt *ctxt, struct lov_stripe_md *lsm,
 195                           int count, struct llog_cookie *cookies, int flags);
 196         int (*lop_connect)(struct llog_ctxt *ctxt, int count,
 197                            struct llog_logid *logid, struct llog_gen *gen,
 198                            struct obd_uuid *uuid);
 199         /* XXX add 2 more: commit callbacks and llog recovery functions */
 200 };
 201
 202 /* llog_lvfs.c */
 203 extern struct llog_operations llog_lvfs_ops;
 204 int llog_get_cat_list(struct obd_device *obd, struct obd_device *disk_obd,
 205                       char *name, int count, struct llog_catid *idarray);
 206
 207 struct llog_ctxt {
 208         int                      loc_idx; /* my index the obd array of ctxt's */
 209         struct llog_gen          loc_gen;
 210         struct obd_device       *loc_obd; /* points back to the containing obd*/
 211         struct obd_llog_group     *loc_olg; /* group containing that ctxt */
 212         struct obd_export       *loc_exp; /* parent "disk" export (e.g. MDS) */
 213         struct obd_import       *loc_imp; /* to use in RPC's: can be backward
 214                                              pointing import */
 215         struct llog_operations  *loc_logops;
 216         struct llog_handle      *loc_handle;
 217         struct llog_canceld_ctxt *loc_llcd;
 218         struct semaphore         loc_sem; /* protects loc_llcd and loc_imp */
 219         atomic_t                   loc_refcount;
 220         struct llog_commit_master *loc_lcm;
 221         void                    *llog_proc_cb;
 222 };
 223
 224 #ifndef __KERNEL__
 225
 226 #define cap_raise(c, flag) do {} while(0)
 227
 228 #define CAP_SYS_RESOURCE 24
 229
 230 #endif   /* !__KERNEL__ */
 231
 232 static inline void llog_gen_init(struct llog_ctxt *ctxt)
 233 {
 234         struct obd_device *obd = ctxt->loc_exp->exp_obd;
 235
 236         if (!strcmp(obd->obd_type->typ_name, LUSTRE_MDS_NAME))
 237                 ctxt->loc_gen.mnt_cnt = obd->u.mds.mds_mount_count;
 238         else if (!strstr(obd->obd_type->typ_name, LUSTRE_OST_NAME))
 239                 ctxt->loc_gen.mnt_cnt = obd->u.filter.fo_mount_count;
 240         else
 241                 ctxt->loc_gen.mnt_cnt = 0;
 242 }
 243
 244 static inline int llog_gen_lt(struct llog_gen a, struct llog_gen b)
 245 {
 246         if (a.mnt_cnt < b.mnt_cnt)
 247                 return 1;
 248         if (a.mnt_cnt > b.mnt_cnt)
 249                 return 0;
 250         return(a.conn_cnt < b.conn_cnt ? 1 : 0);
 251 }
 252
 253 #define LLOG_GEN_INC(gen)  ((gen).conn_cnt ++)
 254 #define LLOG_PROC_BREAK 0x0001
 255 #define LLOG_DEL_RECORD 0x0002
 256
 257 static inline int llog_obd2ops(struct llog_ctxt *ctxt,
 258                                struct llog_operations **lop)
 259 {
 260         if (ctxt == NULL)
 261                 return -ENOTCONN;
 262
 263         *lop = ctxt->loc_logops;
 264         if (*lop == NULL)
 265                 return -EOPNOTSUPP;
 266
 267         return 0;
 268 }
 269
 270 static inline int llog_handle2ops(struct llog_handle *loghandle,
 271                                   struct llog_operations **lop)
 272 {
 273         if (loghandle == NULL)
 274                 return -EINVAL;
 275
 276         return llog_obd2ops(loghandle->lgh_ctxt, lop);
 277 }
 278
 279 static inline int llog_data_len(int len)
 280 {
 281         return size_round(len);
 282 }
 283
 284 static inline struct llog_ctxt *llog_ctxt_get(struct llog_ctxt *ctxt)
 285 {
 286         LASSERT(atomic_read(&ctxt->loc_refcount) > 0);
 287         atomic_inc(&ctxt->loc_refcount);
 288         CDEBUG(D_INFO, "GETting ctxt %p : new refcount %d\n", ctxt,
 289                atomic_read(&ctxt->loc_refcount));
 290         return ctxt;
 291 }
 292
 293 static inline void llog_ctxt_put(struct llog_ctxt *ctxt)
 294 {
 295         if (ctxt == NULL)
 296                 return;
 297         CDEBUG(D_INFO, "PUTting ctxt %p : new refcount %d\n", ctxt,
 298                atomic_read(&ctxt->loc_refcount) - 1);
 299         LASSERT(atomic_read(&ctxt->loc_refcount) > 0);
 300         LASSERT(atomic_read(&ctxt->loc_refcount) < 0x5a5a5a);
 301         __llog_ctxt_put(ctxt);
 302 }
 303
 304 static inline void llog_group_init(struct obd_llog_group *olg, int group)
 305 {
 306         cfs_waitq_init(&olg->olg_waitq);
 307         spin_lock_init(&olg->olg_lock);
 308         olg->olg_group = group;
 309 }
 310
 311 static inline void llog_group_set_export(struct obd_llog_group *olg,
 312                                          struct obd_export *exp)
 313 {
 314         LASSERT(exp != NULL);
 315
 316         spin_lock(&olg->olg_lock);
 317         if (olg->olg_exp != NULL && olg->olg_exp != exp)
 318                 CWARN("%s: export for group %d is changed: 0x%p -> 0x%p\n",
 319                       exp->exp_obd->obd_name, olg->olg_group,
 320                       olg->olg_exp, exp);
 321         olg->olg_exp = exp;
 322         spin_unlock(&olg->olg_lock);
 323 }
 324
 325 static inline int llog_group_set_ctxt(struct obd_llog_group *olg,
 326                                       struct llog_ctxt *ctxt, int index)
 327 {
 328         LASSERT(index >= 0 && index < LLOG_MAX_CTXTS);
 329
 330         spin_lock(&olg->olg_lock);
 331         if (olg->olg_ctxts[index] != NULL) {
 332                 spin_unlock(&olg->olg_lock);
 333                 return -EEXIST;
 334         }
 335         olg->olg_ctxts[index] = ctxt;
 336         spin_unlock(&olg->olg_lock);
 337         return 0;
 338 }
 339
 340 static inline struct llog_ctxt *llog_group_get_ctxt(struct obd_llog_group *olg,
 341                                                     int index)
 342 {
 343         struct llog_ctxt *ctxt;
 344
 345         LASSERT(index >= 0 && index < LLOG_MAX_CTXTS);
 346
 347         spin_lock(&olg->olg_lock);
 348         if (olg->olg_ctxts[index] == NULL) {
 349                 ctxt = NULL;
 350         } else {
 351                 ctxt = llog_ctxt_get(olg->olg_ctxts[index]);
 352         }
 353         spin_unlock(&olg->olg_lock);
 354         return ctxt;
 355 }
 356
 357 static inline struct llog_ctxt *llog_get_context(struct obd_device *obd,
 358                                                  int index)
 359 {
 360         return llog_group_get_ctxt(&obd->obd_olg, index);
 361 }
 362
 363 static inline int llog_group_ctxt_null(struct obd_llog_group *olg, int index)
 364 {
 365         return (olg->olg_ctxts[index] == NULL);
 366 }
 367
 368 static inline int llog_ctxt_null(struct obd_device *obd, int index)
 369 {
 370         return (llog_group_ctxt_null(&obd->obd_olg, index));
 371 }
 372
 373 static inline int llog_write_rec(struct llog_handle *handle,
 374                                  struct llog_rec_hdr *rec,
 375                                  struct llog_cookie *logcookies,
 376                                  int numcookies, void *buf, int idx)
 377 {
 378         struct llog_operations *lop;
 379         __u32 cap;
 380         int rc, buflen;
 381         ENTRY;
 382
 383         rc = llog_handle2ops(handle, &lop);
 384         if (rc)
 385                 RETURN(rc);
 386         LASSERT(lop);
 387         if (lop->lop_write_rec == NULL)
 388                 RETURN(-EOPNOTSUPP);
 389
 390         if (buf)
 391                 buflen = rec->lrh_len + sizeof(struct llog_rec_hdr)
 392                                 + sizeof(struct llog_rec_tail);
 393         else
 394                 buflen = rec->lrh_len;
 395         LASSERT(size_round(buflen) == buflen);
 396
 397         cap = current->cap_effective;
 398         cap_raise(current->cap_effective, CAP_SYS_RESOURCE);
 399         rc = lop->lop_write_rec(handle, rec, logcookies, numcookies, buf, idx);
 400         current->cap_effective = cap;
 401         RETURN(rc);
 402 }
 403
 404 static inline int llog_read_header(struct llog_handle *handle)
 405 {
 406         struct llog_operations *lop;
 407         int rc;
 408         ENTRY;
 409
 410         rc = llog_handle2ops(handle, &lop);
 411         if (rc)
 412                 RETURN(rc);
 413         if (lop->lop_read_header == NULL)
 414                 RETURN(-EOPNOTSUPP);
 415
 416         rc = lop->lop_read_header(handle);
 417         RETURN(rc);
 418 }
 419
 420 static inline int llog_destroy(struct llog_handle *handle)
 421 {
 422         struct llog_operations *lop;
 423         int rc;
 424         ENTRY;
 425
 426         rc = llog_handle2ops(handle, &lop);
 427         if (rc)
 428                 RETURN(rc);
 429         if (lop->lop_destroy == NULL)
 430                 RETURN(-EOPNOTSUPP);
 431
 432         rc = lop->lop_destroy(handle);
 433         RETURN(rc);
 434 }
 435
 436 #if 0
 437 static inline int llog_cancel(struct obd_export *exp,
 438                               struct lov_stripe_md *lsm, int count,
 439                               struct llog_cookie *cookies, int flags)
 440 {
 441         struct llog_operations *lop;
 442         int rc;
 443         ENTRY;
 444
 445         rc = llog_handle2ops(loghandle, &lop);
 446         if (rc)
 447                 RETURN(rc);
 448         if (lop->lop_cancel == NULL)
 449                 RETURN(-EOPNOTSUPP);
 450
 451         rc = lop->lop_cancel(exp, lsm, count, cookies, flags);
 452         RETURN(rc);
 453 }
 454 #endif
 455
 456 static inline int llog_next_block(struct llog_handle *loghandle, int *cur_idx,
 457                                   int next_idx, __u64 *cur_offset, void *buf,
 458                                   int len)
 459 {
 460         struct llog_operations *lop;
 461         int rc;
 462         ENTRY;
 463
 464         rc = llog_handle2ops(loghandle, &lop);
 465         if (rc)
 466                 RETURN(rc);
 467         if (lop->lop_next_block == NULL)
 468                 RETURN(-EOPNOTSUPP);
 469
 470         rc = lop->lop_next_block(loghandle, cur_idx, next_idx, cur_offset, buf,
 471                                  len);
 472         RETURN(rc);
 473 }
 474
 475 static inline int llog_prev_block(struct llog_handle *loghandle,
 476                                   int prev_idx, void *buf, int len)
 477 {
 478         struct llog_operations *lop;
 479         int rc;
 480         ENTRY;
 481
 482         rc = llog_handle2ops(loghandle, &lop);
 483         if (rc)
 484                 RETURN(rc);
 485         if (lop->lop_prev_block == NULL)
 486                 RETURN(-EOPNOTSUPP);
 487
 488         rc = lop->lop_prev_block(loghandle, prev_idx, buf, len);
 489         RETURN(rc);
 490 }
 491
 492 static inline int llog_create(struct llog_ctxt *ctxt, struct llog_handle **res,
 493                               struct llog_logid *logid, char *name)
 494 {
 495         struct llog_operations *lop;
 496         __u32 cap;
 497         int rc;
 498         ENTRY;
 499
 500         rc = llog_obd2ops(ctxt, &lop);
 501         if (rc)
 502                 RETURN(rc);
 503         if (lop->lop_create == NULL)
 504                 RETURN(-EOPNOTSUPP);
 505
 506         cap = current->cap_effective;
 507         cap_raise(current->cap_effective, CAP_SYS_RESOURCE);
 508         rc = lop->lop_create(ctxt, res, logid, name);
 509         current->cap_effective = cap;
 510         RETURN(rc);
 511 }
 512
 513 static inline int llog_connect(struct llog_ctxt *ctxt, int count,
 514                                struct llog_logid *logid, struct llog_gen *gen,
 515                                struct obd_uuid *uuid)
 516 {
 517         struct llog_operations *lop;
 518         int rc;
 519         ENTRY;
 520
 521         rc = llog_obd2ops(ctxt, &lop);
 522         if (rc)
 523                 RETURN(rc);
 524         if (lop->lop_connect == NULL)
 525                 RETURN(-EOPNOTSUPP);
 526
 527         rc = lop->lop_connect(ctxt, count, logid, gen, uuid);
 528         RETURN(rc);
 529 }
 530
 531 #endif