class_obd.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 636 行 · 第 1/2 页

                        GOTO(out, err = -ENODEV);
                }
                CDEBUG(D_HA, "%s: disabling committed-transno notification\n",
                       obd->obd_name);
                obd->obd_no_transno = 1;
                GOTO(out, err = 0);
        }

        default: {
                err = obd_iocontrol(cmd, obd->obd_self_export, len, data, NULL);
                if (err)
                        GOTO(out, err);

                err = obd_ioctl_popdata((void *)arg, data, len);
                if (err)
                        err = -EFAULT;
                GOTO(out, err);
        }
        }

 out:
        if (buf)
                obd_ioctl_freedata(buf, len);
        RETURN(err);
} /* class_handle_ioctl */



#define OBD_MINOR 241
#ifdef __KERNEL__
/* to control /dev/obd */
static int obd_class_ioctl (struct cfs_psdev_file *pfile, unsigned long cmd,
                            void *arg)
{
        return class_handle_ioctl(cmd, (unsigned long)arg);
}

/* declare character device */
struct cfs_psdev_ops obd_psdev_ops = {
        /* .p_open    = */ obd_class_open,      /* open */
        /* .p_close   = */ obd_class_release,   /* release */
        /* .p_read    = */ NULL,
        /* .p_write   = */ NULL,
        /* .p_ioctl   = */ obd_class_ioctl     /* ioctl */
};

extern cfs_psdev_t obd_psdev;
#else
void *obd_psdev = NULL;
#endif

EXPORT_SYMBOL(obd_devs);
EXPORT_SYMBOL(obd_print_fail_loc);
EXPORT_SYMBOL(obd_race_waitq);
EXPORT_SYMBOL(obd_race_state);
EXPORT_SYMBOL(obd_debug_peer_on_timeout);
EXPORT_SYMBOL(obd_dump_on_timeout);
EXPORT_SYMBOL(obd_dump_on_eviction);
EXPORT_SYMBOL(obd_timeout);
EXPORT_SYMBOL(ldlm_timeout);
EXPORT_SYMBOL(obd_max_dirty_pages);
EXPORT_SYMBOL(obd_dirty_pages);
EXPORT_SYMBOL(ptlrpc_put_connection_superhack);

EXPORT_SYMBOL(proc_lustre_root);

EXPORT_SYMBOL(class_register_type);
EXPORT_SYMBOL(class_unregister_type);
EXPORT_SYMBOL(class_get_type);
EXPORT_SYMBOL(class_put_type);
EXPORT_SYMBOL(class_name2dev);
EXPORT_SYMBOL(class_name2obd);
EXPORT_SYMBOL(class_uuid2dev);
EXPORT_SYMBOL(class_uuid2obd);
EXPORT_SYMBOL(class_find_client_obd);
EXPORT_SYMBOL(class_find_client_notype);
EXPORT_SYMBOL(class_devices_in_group);
EXPORT_SYMBOL(class_conn2export);
EXPORT_SYMBOL(class_exp2obd);
EXPORT_SYMBOL(class_conn2obd);
EXPORT_SYMBOL(class_exp2cliimp);
EXPORT_SYMBOL(class_conn2cliimp);
EXPORT_SYMBOL(class_disconnect);
EXPORT_SYMBOL(class_num2obd);

/* uuid.c */
EXPORT_SYMBOL(class_uuid_unparse);
EXPORT_SYMBOL(lustre_uuid_to_peer);

EXPORT_SYMBOL(class_handle_hash);
EXPORT_SYMBOL(class_handle_unhash);
EXPORT_SYMBOL(class_handle2object);
EXPORT_SYMBOL(class_handle_free_cb);

/* obd_config.c */
EXPORT_SYMBOL(class_incref);
EXPORT_SYMBOL(class_decref);
EXPORT_SYMBOL(class_get_profile);
EXPORT_SYMBOL(class_del_profile);
EXPORT_SYMBOL(class_del_profiles);
EXPORT_SYMBOL(class_process_config);
EXPORT_SYMBOL(class_process_proc_param);
EXPORT_SYMBOL(class_config_parse_llog);
EXPORT_SYMBOL(class_config_dump_llog);
EXPORT_SYMBOL(class_attach);
EXPORT_SYMBOL(class_setup);
EXPORT_SYMBOL(class_cleanup);
EXPORT_SYMBOL(class_detach);
EXPORT_SYMBOL(class_manual_cleanup);

#define OBD_INIT_CHECK
#ifdef OBD_INIT_CHECK
int obd_init_checks(void)
{
        __u64 u64val, div64val;
        char buf[64];
        int len, ret = 0;

        CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s, LPSZ=%s, LPSSZ=%s\n",
               LPU64, LPD64, LPX64, LPSZ, LPSSZ);

        CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);

        u64val = OBD_OBJECT_EOF;
        CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
        if (u64val != OBD_OBJECT_EOF) {
                CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                ret = -EINVAL;
        }
        len = snprintf(buf, sizeof(buf), LPX64, u64val);
        if (len != 18) {
                CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
                ret = -EINVAL;
        }

        div64val = OBD_OBJECT_EOF;
        CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
        if (u64val != OBD_OBJECT_EOF) {
                CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                ret = -EOVERFLOW;
        }
        if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
                CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                return -EOVERFLOW;
        }
        if (do_div(div64val, 256) != (u64val & 255)) {
                CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
                return -EOVERFLOW;
        }
        if (u64val >> 8 != div64val) {
                CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
                       u64val, div64val, u64val >> 8);
                return -EOVERFLOW;
        }
        len = snprintf(buf, sizeof(buf), LPX64, u64val);
        if (len != 18) {
                CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
                ret = -EINVAL;
        }
        len = snprintf(buf, sizeof(buf), LPU64, u64val);
        if (len != 20) {
                CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
                ret = -EINVAL;
        }
        len = snprintf(buf, sizeof(buf), LPD64, u64val);
        if (len != 2) {
                CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
                ret = -EINVAL;
        }
        if ((u64val & ~CFS_PAGE_MASK) >= CFS_PAGE_SIZE) {
                CWARN("mask failed: u64val "LPU64" >= %lu\n", u64val, 
                      CFS_PAGE_SIZE);
                ret = -EINVAL;
        }

        return ret;
}
#else
#define obd_init_checks() do {} while(0)
#endif

extern spinlock_t obd_types_lock;
extern int class_procfs_init(void);
extern int class_procfs_clean(void);

#ifdef __KERNEL__
static int __init init_obdclass(void)
#else
int init_obdclass(void)
#endif
{
        int i, err;
#ifdef __KERNEL__
        int lustre_register_fs(void);

        printk(KERN_INFO "Lustre: OBD class driver, [e-mail]\n");
        printk(KERN_INFO "        Lustre Version: "LUSTRE_VERSION_STRING"\n");
        printk(KERN_INFO "        Build Version: "BUILD_VERSION"\n");
#else
        CDEBUG(D_INFO, "Lustre: OBD class driver, [e-mail]\n");
        CDEBUG(D_INFO, "        Lustre Version: "LUSTRE_VERSION_STRING"\n");
        CDEBUG(D_INFO, "        Build Version: "BUILD_VERSION"\n");
#endif

        spin_lock_init(&obd_types_lock);
        cfs_waitq_init(&obd_race_waitq);
        obd_zombie_impexp_init();
#ifdef LPROCFS
        obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM, 
                                         LPROCFS_STATS_FLAG_PERCPU);
        if (obd_memory == NULL) {
                CERROR("kmalloc of 'obd_memory' failed\n");
                RETURN(-ENOMEM);
        }

        lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
                             LPROCFS_CNTR_AVGMINMAX, 
                             "memused", "bytes");
        lprocfs_counter_init(obd_memory, OBD_MEMORY_PAGES_STAT,
                             LPROCFS_CNTR_AVGMINMAX, 
                             "pagesused", "pages");
#endif
        err = obd_init_checks();
        if (err == -EOVERFLOW)
                return err;

        class_init_uuidlist();
        err = class_handle_init();
        if (err)
                return err;

        spin_lock_init(&obd_dev_lock);
        CFS_INIT_LIST_HEAD(&obd_types);

        err = cfs_psdev_register(&obd_psdev);
        if (err) {
                CERROR("cannot register %d err %d\n", OBD_MINOR, err);
                return err;
        }

        /* This struct is already zerod for us (static global) */
        for (i = 0; i < class_devno_max(); i++)
                obd_devs[i] = NULL;

        /* Default the dirty page cache cap to 1/2 of system memory */
        obd_max_dirty_pages = num_physpages / 2;

        err = obd_init_caches();
        if (err)
                return err;
#ifdef __KERNEL__
        err = class_procfs_init();
        if (err)
                return err;
        err = lustre_register_fs();
#endif

        return err;
}

/* liblustre doesn't call cleanup_obdclass, apparently.  we carry on in this
 * ifdef to the end of the file to cover module and versioning goo.*/
#ifdef __KERNEL__
static void cleanup_obdclass(void)
{
        int i;
        __u64 memory_leaked, pages_leaked;
        __u64 memory_max, pages_max;
        int lustre_unregister_fs(void);
        ENTRY;

        lustre_unregister_fs();

        cfs_psdev_deregister(&obd_psdev);
        for (i = 0; i < class_devno_max(); i++) {
                struct obd_device *obd = class_num2obd(i);
                if (obd && obd->obd_set_up &&
                    OBT(obd) && OBP(obd, detach)) {
                        /* XXX should this call generic detach otherwise? */
                        LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
                        OBP(obd, detach)(obd);
                }
        }

        obd_cleanup_caches();
        obd_sysctl_clean();

        class_procfs_clean();

        class_handle_cleanup();
        class_exit_uuidlist();

        memory_leaked = obd_memory_sum();
        pages_leaked = obd_pages_sum();

        memory_max = obd_memory_max();
        pages_max = obd_pages_max();

        lprocfs_free_stats(&obd_memory);
        CDEBUG((memory_leaked | pages_leaked) ? D_ERROR : D_INFO,
               "obd_memory max: "LPU64", leaked: "LPU64" "
               "obd_memory_pages max: "LPU64", leaked: "LPU64"\n",
               memory_max, memory_leaked, 
               pages_max, pages_leaked);

        EXIT;
}

MODULE_AUTHOR("Cluster File Systems, Inc. <[e-mail]>");
MODULE_DESCRIPTION("Lustre Class Driver Build Version: " BUILD_VERSION);
MODULE_LICENSE("GPL");

cfs_module(obdclass, LUSTRE_VERSION_STRING, init_obdclass, cleanup_obdclass);
#endif