lustre/osd/osd_handler.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/osd/osd_handler.c
   5  *  Top-level entry points into osd module
   6  *
   7  *  Copyright (c) 2006 Cluster File Systems, Inc.
   8  *   Author: Nikita Danilov <nikita@clusterfs.com>
   9  *
  10  *   This file is part of the Lustre file system, http://www.lustre.org
  11  *   Lustre is a trademark of Cluster File Systems, Inc.
  12  *
  13  *   You may have signed or agreed to another license before downloading
  14  *   this software.  If so, you are bound by the terms and conditions
  15  *   of that agreement, and the following does not apply to you.  See the
  16  *   LICENSE file included with this distribution for more information.
  17  *
  18  *   If you did not agree to a different license, then this copy of Lustre
  19  *   is open source software; you can redistribute it and/or modify it
  20  *   under the terms of version 2 of the GNU General Public License as
  21  *   published by the Free Software Foundation.
  22  *
  23  *   In either case, Lustre is distributed in the hope that it will be
  24  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  25  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *   license text for more details.
  27  */
  28
  29 #ifndef EXPORT_SYMTAB
  30 # define EXPORT_SYMTAB
  31 #endif
  32 #define DEBUG_SUBSYSTEM S_MDS
  33
  34 #include <linux/module.h>
  35
  36 /* LUSTRE_VERSION_CODE */
  37 #include <linux/lustre_ver.h>
  38 /*
  39  * struct OBD_{ALLOC,FREE}*()
  40  * OBD_FAIL_CHECK
  41  */
  42 #include <linux/obd_support.h>
  43 /* struct ptlrpc_thread */
  44 #include <linux/lustre_net.h>
  45 /* LUSTRE_OSD0_NAME */
  46 #include <linux/obd.h>
  47 /* class_register_type(), class_unregister_type(), class_get_type() */
  48 #include <linux/obd_class.h>
  49 #include <linux/lustre_disk.h>
  50
  51 /* fid_is_local() */
  52 #include <linux/lustre_fid.h>
  53
  54 #include "osd_internal.h"
  55
  56 static int   osd_root_get      (struct lu_context *ctxt,
  57                                 struct dt_device *dev, struct lu_fid *f);
  58 static int   osd_statfs        (struct lu_context *ctxt,
  59                                 struct dt_device *dev, struct kstatfs *sfs);
  60
  61 static int   lu_device_is_osd  (const struct lu_device *d);
  62 static void  osd_mod_exit      (void) __exit;
  63 static int   osd_mod_init      (void) __init;
  64 static int   osd_type_init     (struct lu_device_type *t);
  65 static void  osd_type_fini     (struct lu_device_type *t);
  66 static int   osd_object_init   (struct lu_context *ctxt, struct lu_object *l);
  67 static void  osd_object_release(struct lu_context *ctxt, struct lu_object *l);
  68 static int   osd_object_print  (struct lu_context *ctx,
  69                                 struct seq_file *f, const struct lu_object *o);
  70 static void  osd_device_free   (struct lu_device *m);
  71 static struct lu_device *osd_device_fini   (struct lu_device *d);
  72 static int   osd_device_init   (struct lu_device *d, struct lu_device *);
  73 static void *osd_key_init      (struct lu_context *ctx);
  74 static void  osd_key_fini      (struct lu_context *ctx, void *data);
  75 static int   osd_fid_lookup    (struct lu_context *ctx, struct osd_object *obj,
  76                                 const struct lu_fid *fid);
  77 static int   osd_inode_getattr (struct lu_context *ctx,
  78                                 struct inode *inode, struct lu_attr *attr);
  79
  80 static struct osd_object  *osd_obj          (const struct lu_object *o);
  81 static struct osd_device  *osd_dev          (const struct lu_device *d);
  82 static struct osd_device  *osd_dt_dev       (const struct dt_device *d);
  83 static struct lu_device   *osd_device_alloc (struct lu_device_type *t,
  84                                              struct lustre_cfg *cfg);
  85 static struct lu_object   *osd_object_alloc (struct lu_context *ctx,
  86                                              struct lu_device *d);
  87 static struct inode       *osd_iget         (struct osd_thread_info *info,
  88                                              struct osd_device *dev,
  89                                              const struct osd_inode_id *id);
  90 static struct super_block *osd_sb           (const struct osd_device *dev);
  91 static struct lu_fid      *osd_inode_get_fid(const struct inode *inode,
  92                                              struct lu_fid *fid);
  93
  94 static struct lu_device_type_operations osd_device_type_ops;
  95 static struct lu_device_type            osd_device_type;
  96 static struct obd_ops                   osd_obd_device_ops;
  97 static struct lprocfs_vars              lprocfs_osd_module_vars[];
  98 static struct lprocfs_vars              lprocfs_osd_obd_vars[];
  99 static struct lu_device_operations      osd_lu_ops;
 100 static struct lu_context_key            osd_key;
 101 static struct dt_object_operations      osd_obj_ops;
 102
 103 /*
 104  * DT methods.
 105  */
 106 static int osd_root_get(struct lu_context *ctx,
 107                         struct dt_device *dev, struct lu_fid *f)
 108 {
 109         osd_inode_get_fid(osd_dt_dev(dev)->od_root_dir->d_inode, f);
 110         return 0;
 111 }
 112
 113
 114 /*
 115  * OSD object methods.
 116  */
 117
 118 static struct lu_object *osd_object_alloc(struct lu_context *ctx,
 119                                           struct lu_device *d)
 120 {
 121         struct osd_object *mo;
 122
 123         OBD_ALLOC_PTR(mo);
 124         if (mo != NULL) {
 125                 struct lu_object *l;
 126
 127                 l = &mo->oo_dt.do_lu;
 128                 lu_object_init(l, NULL, d);
 129                 mo->oo_dt.do_ops = &osd_obj_ops;
 130                 return l;
 131         } else
 132                 return NULL;
 133 }
 134
 135 static int osd_object_init(struct lu_context *ctxt, struct lu_object *l)
 136 {
 137         return osd_fid_lookup(ctxt, osd_obj(l), lu_object_fid(l));
 138 }
 139
 140 static void osd_object_free(struct lu_context *ctx, struct lu_object *l)
 141 {
 142         struct osd_object *obj = osd_obj(l);
 143         OBD_FREE_PTR(obj);
 144 }
 145
 146 static void osd_object_delete(struct lu_context *ctx, struct lu_object *l)
 147 {
 148         struct osd_object *o = osd_obj(l);
 149
 150         if (o->oo_inode != NULL)
 151                 iput(o->oo_inode);
 152 }
 153
 154 static int osd_inode_unlinked(const struct inode *inode)
 155 {
 156         return inode->i_nlink == !!S_ISDIR(inode->i_mode);
 157 }
 158
 159 static void osd_object_release(struct lu_context *ctxt, struct lu_object *l)
 160 {
 161         struct osd_object *o = osd_obj(l);
 162
 163         if (o->oo_inode != NULL && osd_inode_unlinked(o->oo_inode))
 164                 set_bit(LU_OBJECT_HEARD_BANSHEE, &l->lo_header->loh_flags);
 165 }
 166
 167 static int osd_object_print(struct lu_context *ctx,
 168                             struct seq_file *f, const struct lu_object *l)
 169 {
 170         struct osd_object  *o = osd_obj(l);
 171
 172         return seq_printf(f, LUSTRE_OSD0_NAME"-object@%p(i:%p:%lu/%u)",
 173                           o, o->oo_inode,
 174                           o->oo_inode ? o->oo_inode->i_ino : 0UL,
 175                           o->oo_inode ? o->oo_inode->i_generation : 0);
 176 }
 177
 178 static int osd_config(struct lu_context *ctx,
 179                       struct dt_device *d, const char *name,
 180                       void *buf, int size, int mode)
 181 {
 182         if (mode == LUSTRE_CONFIG_GET) {
 183                 /* to be continued */
 184                 return 0;
 185         } else {
 186                 /* to be continued */
 187                 return 0;
 188         }
 189 }
 190
 191 static int osd_statfs(struct lu_context *ctx,
 192                       struct dt_device *d, struct kstatfs *sfs)
 193 {
 194         struct osd_device *osd = dt2osd_dev(d);
 195         struct super_block *sb = osd_sb(osd);
 196         int result;
 197
 198         ENTRY;
 199
 200         memset(sfs, 0, sizeof(*sfs));
 201         result = sb->s_op->statfs(sb, sfs);
 202
 203         RETURN (result);
 204 }
 205
 206 static int osd_attr_get(struct lu_context *ctxt, struct dt_object *dt,
 207                         struct lu_attr *attr)
 208 {
 209         return osd_inode_getattr(ctxt, dt2osd_obj(dt)->oo_inode, attr);
 210 }
 211
 212 static struct dt_object_operations osd_obj_ops = {
 213         .do_attr_get = osd_attr_get
 214 };
 215
 216 static struct dt_device_operations osd_dt_ops = {
 217         .dt_root_get = osd_root_get,
 218         .dt_config   = osd_config,
 219         .dt_statfs   = osd_statfs
 220 };
 221
 222 /*
 223  * OSD device type methods
 224  */
 225 static int osd_type_init(struct lu_device_type *t)
 226 {
 227         return lu_context_key_register(&osd_key);
 228 }
 229
 230 static void osd_type_fini(struct lu_device_type *t)
 231 {
 232         lu_context_key_degister(&osd_key);
 233 }
 234
 235 static struct lu_context_key osd_key = {
 236         .lct_init = osd_key_init,
 237         .lct_fini = osd_key_fini
 238 };
 239
 240 static void *osd_key_init(struct lu_context *ctx)
 241 {
 242         struct osd_thread_info *info;
 243
 244         OBD_ALLOC_PTR(info);
 245         if (info == NULL)
 246                 info = ERR_PTR(-ENOMEM);
 247         return info;
 248 }
 249
 250 static void osd_key_fini(struct lu_context *ctx, void *data)
 251 {
 252         struct osd_thread_info *info = data;
 253         OBD_FREE_PTR(info);
 254 }
 255
 256 static int osd_device_init(struct lu_device *d, struct lu_device *next)
 257 {
 258         return 0;
 259 }
 260
 261 static int osd_mount(struct osd_device *o, struct lustre_cfg *cfg)
 262 {
 263         struct lustre_mount_info *lmi;
 264         const char *dev = lustre_cfg_string(cfg, 0);
 265         int result;
 266
 267         ENTRY;
 268
 269         /* get mount */
 270         lmi = server_get_mount(dev);
 271         if (lmi == NULL) {
 272                 CERROR("Cannot get mount info for %s!\n", dev);
 273                 RETURN(-EFAULT);
 274         }
 275
 276         LASSERT(lmi != NULL);
 277         /* save lustre_mount_info in dt_device */
 278         o->od_mount = lmi;
 279         result = osd_oi_init(&o->od_oi, osd_sb(o)->s_root,
 280                              o->od_dt_dev.dd_lu_dev.ld_site);
 281
 282         if (result == 0) {
 283                 o->od_root_dir = osd_open(osd_sb(o)->s_root,
 284                                           "ROOT", S_IFDIR);
 285                 if (IS_ERR(o->od_root_dir)) {
 286                         result = PTR_ERR(o->od_root_dir);
 287                         o->od_root_dir = NULL;
 288                 }
 289         }
 290
 291         RETURN(result);
 292 }
 293
 294 static struct lu_device *osd_device_fini(struct lu_device *d)
 295 {
 296         struct osd_device *o = osd_dev(d);
 297         ENTRY;
 298         if (o->od_root_dir != NULL) {
 299                 dput(o->od_root_dir);
 300                 o->od_root_dir = NULL;
 301         }
 302         osd_oi_fini(&o->od_oi);
 303
 304         server_put_mount(o->od_mount->lmi_name, o->od_mount->lmi_mnt);
 305
 306         o->od_mount = NULL;
 307
 308         return NULL;
 309 }
 310
 311 static struct lu_device *osd_device_alloc(struct lu_device_type *t,
 312                                           struct lustre_cfg *cfg)
 313 {
 314         struct lu_device  *l;
 315         struct osd_device *o;
 316
 317         OBD_ALLOC_PTR(o);
 318         if (o != NULL) {
 319                 l = &o->od_dt_dev.dd_lu_dev;
 320                 lu_device_init(&o->od_dt_dev.dd_lu_dev, t);
 321                 o->od_dt_dev.dd_lu_dev.ld_ops = &osd_lu_ops;
 322                 o->od_dt_dev.dd_ops = &osd_dt_ops;
 323         } else
 324                 l = ERR_PTR(-ENOMEM);
 325         return l;
 326 }
 327
 328 static void osd_device_free(struct lu_device *d)
 329 {
 330         struct osd_device *o = osd_dev(d);
 331
 332         lu_device_fini(d);
 333         OBD_FREE_PTR(o);
 334 }
 335
 336 static int osd_process_config(struct lu_device *d, struct lustre_cfg *cfg)
 337 {
 338         struct osd_device *o = lu2osd_dev(d);
 339         int err;
 340
 341         switch(cfg->lcfg_command) {
 342         case LCFG_SETUP:
 343                 err = osd_mount(o, cfg);
 344         }
 345
 346         RETURN(err);
 347 }
 348
 349 /*
 350  * fid<->inode<->object functions.
 351  */
 352
 353 static struct lu_fid *osd_inode_get_fid(const struct inode *inode,
 354                                         struct lu_fid *fid)
 355 {
 356         /*
 357          * XXX: Should return fid stored together with inode in memory.
 358          */
 359         fid->f_seq = inode->i_ino;
 360         fid->f_oid = inode->i_generation;
 361         return fid;
 362 }
 363
 364 struct dentry *osd_open(struct dentry *parent, const char *name, mode_t mode)
 365 {
 366         struct dentry *dentry;
 367         struct dentry *result;
 368
 369         result = dentry = osd_lookup(parent, name);
 370         if (IS_ERR(dentry)) {
 371                 CERROR("Error opening %s: %ld\n", name, PTR_ERR(dentry));
 372                 dentry = NULL; /* dput(NULL) below is OK */
 373         } else if (dentry->d_inode == NULL) {
 374                 CERROR("Not found: %s\n", name);
 375                 result = ERR_PTR(-ENOENT);
 376         } else if ((dentry->d_inode->i_mode & S_IFMT) != mode) {
 377                 CERROR("Wrong mode: %s: %o != %o\n", name,
 378                        dentry->d_inode->i_mode, mode);
 379                 result = ERR_PTR(mode == S_IFDIR ? -ENOTDIR : -EISDIR);
 380         }
 381
 382         if (IS_ERR(result))
 383                 dput(dentry);
 384         return result;
 385 }
 386
 387 struct dentry *osd_lookup(struct dentry *parent, const char *name)
 388 {
 389         struct dentry *dentry;
 390
 391         CDEBUG(D_INODE, "looking up object %s\n", name);
 392         down(&parent->d_inode->i_sem);
 393         dentry = lookup_one_len(name, parent, strlen(name));
 394         up(&parent->d_inode->i_sem);
 395
 396         if (IS_ERR(dentry)) {
 397                 CERROR("error getting %s: %ld\n", name, PTR_ERR(dentry));
 398         } else if (dentry->d_inode != NULL && is_bad_inode(dentry->d_inode)) {
 399                 CERROR("got bad object %s inode %lu\n",
 400                        name, dentry->d_inode->i_ino);
 401                 dput(dentry);
 402                 dentry = ERR_PTR(-ENOENT);
 403         }
 404         return dentry;
 405 }
 406
 407 static struct inode *osd_iget(struct osd_thread_info *info,
 408                               struct osd_device *dev,
 409                               const struct osd_inode_id *id)
 410 {
 411         struct inode *inode;
 412
 413         inode = iget(osd_sb(dev), id->oii_ino);
 414         if (inode == NULL) {
 415                 CERROR("no inode\n");
 416                 inode = ERR_PTR(-EACCES);
 417         } else if (is_bad_inode(inode)) {
 418                 CERROR("bad inode\n");
 419                 iput(inode);
 420                 inode = ERR_PTR(-ENOENT);
 421         } else if (inode->i_generation != id->oii_gen &&
 422                    id->oii_gen != OSD_GEN_IGNORE) {
 423                 CERROR("stale inode\n");
 424                 iput(inode);
 425                 inode = ERR_PTR(-ESTALE);
 426         }
 427         return inode;
 428
 429 }
 430
 431 static int osd_fid_lookup(struct lu_context *ctx,
 432                           struct osd_object *obj, const struct lu_fid *fid)
 433 {
 434         struct osd_thread_info *info;
 435         struct lu_device       *ldev = obj->oo_dt.do_lu.lo_dev;
 436         struct osd_device      *dev;
 437         struct osd_inode_id     id;
 438         struct inode           *inode;
 439         int                     result;
 440
 441         LASSERT(obj->oo_inode == NULL);
 442         LASSERT(fid_is_sane(fid));
 443         LASSERT(fid_is_local(ldev->ld_site, fid));
 444
 445         ENTRY;
 446
 447         info = lu_context_key_get(ctx, &osd_key);
 448         dev  = osd_dev(ldev);
 449
 450         if (OBD_FAIL_CHECK(OBD_FAIL_OST_ENOENT))
 451                 RETURN(-ENOENT);
 452
 453         osd_oi_read_lock(&dev->od_oi);
 454         result = osd_oi_lookup(info, &dev->od_oi, fid, &id);
 455         if (result == 0) {
 456                 inode = osd_iget(info, dev, &id);
 457                 if (!IS_ERR(inode)) {
 458                         obj->oo_inode = inode;
 459                         result = 0;
 460                 } else
 461                         result = PTR_ERR(inode);
 462         }
 463         osd_oi_read_unlock(&dev->od_oi);
 464         RETURN(result);
 465 }
 466
 467 static int osd_inode_getattr(struct lu_context *ctx,
 468                              struct inode *inode, struct lu_attr *attr)
 469 {
 470         //attr->la_atime      = inode->i_atime;
 471         //attr->la_mtime      = inode->i_mtime;
 472         //attr->la_ctime      = inode->i_ctime;
 473         attr->la_mode       = inode->i_mode;
 474         attr->la_size       = inode->i_size;
 475         attr->la_blocks     = inode->i_blocks;
 476         attr->la_uid        = inode->i_uid;
 477         attr->la_gid        = inode->i_gid;
 478         attr->la_flags      = inode->i_flags;
 479         attr->la_nlink      = inode->i_nlink;
 480         return 0;
 481 }
 482
 483 /*
 484  * Helpers.
 485  */
 486
 487 static int lu_device_is_osd(const struct lu_device *d)
 488 {
 489         /*
 490          * XXX for now. Tags in lu_device_type->ldt_something are needed.
 491          */
 492         return ergo(d->ld_ops != NULL, d->ld_ops == &osd_lu_ops);
 493 }
 494
 495 static struct osd_object *osd_obj(const struct lu_object *o)
 496 {
 497         LASSERT(lu_device_is_osd(o->lo_dev));
 498         return container_of(o, struct osd_object, oo_dt.do_lu);
 499 }
 500
 501 static struct osd_device *osd_dt_dev(const struct dt_device *d)
 502 {
 503         LASSERT(lu_device_is_osd(&d->dd_lu_dev));
 504         return container_of(d, struct osd_device, od_dt_dev);
 505 }
 506
 507 static struct osd_device *osd_dev(const struct lu_device *d)
 508 {
 509         LASSERT(lu_device_is_osd(d));
 510         return osd_dt_dev(container_of(d, struct dt_device, dd_lu_dev));
 511 }
 512
 513 static struct super_block *osd_sb(const struct osd_device *dev)
 514 {
 515         return dev->od_mount->lmi_mnt->mnt_sb;
 516 }
 517
 518 static struct lu_device_operations osd_lu_ops = {
 519         .ldo_object_alloc   = osd_object_alloc,
 520         .ldo_object_init    = osd_object_init,
 521         .ldo_object_free    = osd_object_free,
 522         .ldo_object_release = osd_object_release,
 523         .ldo_object_delete  = osd_object_delete,
 524         .ldo_object_print   = osd_object_print,
 525         .ldo_process_config = osd_process_config
 526 };
 527
 528 static struct lu_device_type_operations osd_device_type_ops = {
 529         .ldto_init = osd_type_init,
 530         .ldto_fini = osd_type_fini,
 531
 532         .ldto_device_alloc = osd_device_alloc,
 533         .ldto_device_free  = osd_device_free,
 534
 535         .ldto_device_init    = osd_device_init,
 536         .ldto_device_fini    = osd_device_fini
 537 };
 538
 539 static struct lu_device_type osd_device_type = {
 540         .ldt_tags = LU_DEVICE_DT,
 541         .ldt_name = LUSTRE_OSD0_NAME,
 542         .ldt_ops  = &osd_device_type_ops
 543 };
 544
 545 /*
 546  * lprocfs legacy support.
 547  */
 548 static struct lprocfs_vars lprocfs_osd_obd_vars[] = {
 549         { 0 }
 550 };
 551
 552 static struct lprocfs_vars lprocfs_osd_module_vars[] = {
 553         { 0 }
 554 };
 555
 556 static struct obd_ops osd_obd_device_ops = {
 557         .o_owner = THIS_MODULE
 558 };
 559
 560 LPROCFS_INIT_VARS(osd, lprocfs_osd_module_vars, lprocfs_osd_obd_vars);
 561
 562 static int __init osd_mod_init(void)
 563 {
 564         struct lprocfs_static_vars lvars;
 565
 566         lprocfs_init_vars(osd, &lvars);
 567         return class_register_type(&osd_obd_device_ops, lvars.module_vars,
 568                                    LUSTRE_OSD0_NAME, &osd_device_type);
 569 }
 570
 571 static void __exit osd_mod_exit(void)
 572 {
 573         class_unregister_type(LUSTRE_OSD0_NAME);
 574 }
 575
 576 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
 577 MODULE_DESCRIPTION("Lustre Object Storage Device ("LUSTRE_OSD0_NAME")");
 578 MODULE_LICENSE("GPL");
 579
 580 cfs_module(osd, "0.0.2", osd_mod_init, osd_mod_exit);