1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 only,
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License version 2 for more details (a copy is included
16 * in the LICENSE file that accompanied this code).
18 * You should have received a copy of the GNU General Public License
19 * version 2 along with this program; If not, see
20 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
29 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
30 * Use is subject to license terms.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * cl_device and cl_device_type implementation for VVP layer.
38 * Author: Nikita Danilov <nikita.danilov@sun.com>
41 #define DEBUG_SUBSYSTEM S_LLITE
44 # error This file is kernel only.
48 #include <lustre_lite.h>
50 #include "vvp_internal.h"
52 /*****************************************************************************
54 * Vvp device and device type functions.
59 * vvp_ prefix stands for "Vfs Vm Posix". It corresponds to historical
60 * "llite_" (var. "ll_") prefix.
63 cfs_mem_cache_t *vvp_page_kmem;
64 cfs_mem_cache_t *vvp_thread_kmem;
65 static cfs_mem_cache_t *vvp_session_kmem;
66 static struct lu_kmem_descr vvp_caches[] = {
68 .ckd_cache = &vvp_page_kmem,
69 .ckd_name = "vvp_page_kmem",
70 .ckd_size = sizeof (struct ccc_page)
73 .ckd_cache = &vvp_thread_kmem,
74 .ckd_name = "vvp_thread_kmem",
75 .ckd_size = sizeof (struct vvp_thread_info),
78 .ckd_cache = &vvp_session_kmem,
79 .ckd_name = "vvp_session_kmem",
80 .ckd_size = sizeof (struct vvp_session)
87 static void *vvp_key_init(const struct lu_context *ctx,
88 struct lu_context_key *key)
90 struct vvp_thread_info *info;
92 OBD_SLAB_ALLOC_PTR_GFP(info, vvp_thread_kmem, CFS_ALLOC_IO);
94 info = ERR_PTR(-ENOMEM);
98 static void vvp_key_fini(const struct lu_context *ctx,
99 struct lu_context_key *key, void *data)
101 struct vvp_thread_info *info = data;
102 OBD_SLAB_FREE_PTR(info, vvp_thread_kmem);
105 static void *vvp_session_key_init(const struct lu_context *ctx,
106 struct lu_context_key *key)
108 struct vvp_session *session;
110 OBD_SLAB_ALLOC_PTR_GFP(session, vvp_session_kmem, CFS_ALLOC_IO);
112 session = ERR_PTR(-ENOMEM);
116 static void vvp_session_key_fini(const struct lu_context *ctx,
117 struct lu_context_key *key, void *data)
119 struct vvp_session *session = data;
120 OBD_SLAB_FREE_PTR(session, vvp_session_kmem);
124 struct lu_context_key vvp_key = {
125 .lct_tags = LCT_CL_THREAD,
126 .lct_init = vvp_key_init,
127 .lct_fini = vvp_key_fini
130 struct lu_context_key vvp_session_key = {
131 .lct_tags = LCT_SESSION,
132 .lct_init = vvp_session_key_init,
133 .lct_fini = vvp_session_key_fini
136 /* type constructor/destructor: vvp_type_{init,fini,start,stop}(). */
137 LU_TYPE_INIT_FINI(vvp, &ccc_key, &ccc_session_key, &vvp_key, &vvp_session_key);
139 static const struct lu_device_operations vvp_lu_ops = {
140 .ldo_object_alloc = vvp_object_alloc
143 static const struct cl_device_operations vvp_cl_ops = {
144 .cdo_req_init = ccc_req_init
147 static struct lu_device *vvp_device_alloc(const struct lu_env *env,
148 struct lu_device_type *t,
149 struct lustre_cfg *cfg)
151 return ccc_device_alloc(env, t, cfg, &vvp_lu_ops, &vvp_cl_ops);
154 static const struct lu_device_type_operations vvp_device_type_ops = {
155 .ldto_init = vvp_type_init,
156 .ldto_fini = vvp_type_fini,
158 .ldto_start = vvp_type_start,
159 .ldto_stop = vvp_type_stop,
161 .ldto_device_alloc = vvp_device_alloc,
162 .ldto_device_free = ccc_device_free,
163 .ldto_device_init = ccc_device_init,
164 .ldto_device_fini = ccc_device_fini
167 struct lu_device_type vvp_device_type = {
168 .ldt_tags = LU_DEVICE_CL,
169 .ldt_name = LUSTRE_VVP_NAME,
170 .ldt_ops = &vvp_device_type_ops,
171 .ldt_ctx_tags = LCT_CL_THREAD
175 * A mutex serializing calls to vvp_inode_fini() under extreme memory
176 * pressure, when environments cannot be allocated.
178 int vvp_global_init(void)
182 result = lu_kmem_init(vvp_caches);
184 result = ccc_global_init(&vvp_device_type);
186 lu_kmem_fini(vvp_caches);
191 void vvp_global_fini(void)
193 ccc_global_fini(&vvp_device_type);
194 lu_kmem_fini(vvp_caches);
198 /*****************************************************************************
200 * mirror obd-devices into cl devices.
204 int cl_sb_init(struct super_block *sb)
206 struct ll_sb_info *sbi;
207 struct cl_device *cl;
213 env = cl_env_get(&refcheck);
215 cl = cl_type_setup(env, NULL, &vvp_device_type,
216 sbi->ll_dt_exp->exp_obd->obd_lu_dev);
218 cl2ccc_dev(cl)->cdv_sb = sb;
220 sbi->ll_site = cl2lu_dev(cl)->ld_site;
222 cl_env_put(env, &refcheck);
228 int cl_sb_fini(struct super_block *sb)
230 struct ll_sb_info *sbi;
232 struct cl_device *cld;
238 env = cl_env_get(&refcheck);
243 cl_stack_fini(env, cld);
247 cl_env_put(env, &refcheck);
250 CERROR("Cannot cleanup cl-stack due to memory shortage.\n");
251 result = PTR_ERR(env);
254 * If mount failed (sbi->ll_cl == NULL), and this there are no other
255 * mounts, stop device types manually (this usually happens
256 * automatically when last device is destroyed).
262 /****************************************************************************
264 * /proc/fs/lustre/llite/$MNT/dump_page_cache
266 ****************************************************************************/
269 * To represent contents of a page cache as a byte stream, following
270 * information if encoded in 64bit offset:
272 * - file hash bucket in lu_site::ls_hash[] 28bits
274 * - how far file is from bucket head 4bits
276 * - page index 32bits
278 * First two data identify a file in the cache uniquely.
281 #define PGC_OBJ_SHIFT (32 + 4)
282 #define PGC_DEPTH_SHIFT (32)
284 struct vvp_pgcache_id {
290 static void vvp_pgcache_id_unpack(loff_t pos, struct vvp_pgcache_id *id)
292 CLASSERT(sizeof(pos) == sizeof(__u64));
294 id->vpi_index = pos & 0xffffffff;
295 id->vpi_depth = (pos >> PGC_DEPTH_SHIFT) & 0xf;
296 id->vpi_bucket = ((unsigned long long)pos >> PGC_OBJ_SHIFT);
299 static loff_t vvp_pgcache_id_pack(struct vvp_pgcache_id *id)
302 ((__u64)id->vpi_index) |
303 ((__u64)id->vpi_depth << PGC_DEPTH_SHIFT) |
304 ((__u64)id->vpi_bucket << PGC_OBJ_SHIFT);
307 static struct cl_object *vvp_pgcache_obj(const struct lu_env *env,
308 struct lu_device *dev,
309 struct vvp_pgcache_id *id)
311 cfs_hlist_head_t *bucket;
312 struct lu_object_header *hdr;
313 struct lu_site *site;
314 cfs_hlist_node_t *scan;
315 struct lu_object_header *found;
316 struct cl_object *clob;
319 LASSERT(lu_device_is_cl(dev));
322 bucket = site->ls_hash + (id->vpi_bucket & site->ls_hash_mask);
323 depth = id->vpi_depth & 0xf;
327 /* XXX copy of lu_object.c:htable_lookup() */
328 cfs_read_lock(&site->ls_guard);
329 cfs_hlist_for_each_entry(hdr, scan, bucket, loh_hash) {
331 if (!lu_object_is_dying(hdr)) {
332 if (cfs_atomic_add_return(1,
340 cfs_read_unlock(&site->ls_guard);
343 struct lu_object *lu_obj;
345 lu_obj = lu_object_locate(found, dev->ld_type);
346 if (lu_obj != NULL) {
347 lu_object_ref_add(lu_obj, "dump", cfs_current());
348 clob = lu2cl(lu_obj);
350 lu_object_put(env, lu_object_top(found));
351 } else if (depth > 0)
356 static loff_t vvp_pgcache_find(const struct lu_env *env,
357 struct lu_device *dev, loff_t pos)
359 struct cl_object *clob;
360 struct lu_site *site;
361 struct vvp_pgcache_id id;
364 vvp_pgcache_id_unpack(pos, &id);
367 if (id.vpi_bucket >= site->ls_hash_size)
369 clob = vvp_pgcache_obj(env, dev, &id);
371 struct cl_object_header *hdr;
375 /* got an object. Find next page. */
376 hdr = cl_object_header(clob);
378 cfs_spin_lock(&hdr->coh_page_guard);
379 nr = radix_tree_gang_lookup(&hdr->coh_tree,
383 id.vpi_index = pg->cp_index;
384 /* Cant support over 16T file */
385 nr = !(pg->cp_index > 0xffffffff);
387 cfs_spin_unlock(&hdr->coh_page_guard);
389 lu_object_ref_del(&clob->co_lu, "dump", cfs_current());
390 cl_object_put(env, clob);
392 return vvp_pgcache_id_pack(&id);
394 /* to the next object. */
397 if (id.vpi_depth == 0 && ++id.vpi_bucket == 0)
403 #define seq_page_flag(seq, page, flag, has_flags) do { \
404 if (cfs_test_bit(PG_##flag, &(page)->flags)) { \
405 seq_printf(seq, "%s"#flag, has_flags ? "|" : ""); \
410 static void vvp_pgcache_page_show(const struct lu_env *env,
411 struct seq_file *seq, struct cl_page *page)
413 struct ccc_page *cpg;
417 cpg = cl2ccc_page(cl_page_at(page, &vvp_device_type));
418 vmpage = cpg->cpg_page;
419 seq_printf(seq," %5i | %p %p %s %s %s %s | %p %lu/%u(%p) %lu %u [",
423 cpg->cpg_write_queued ? "wq" : "- ",
424 cpg->cpg_defer_uptodate ? "du" : "- ",
425 PageWriteback(vmpage) ? "wb" : "-",
426 vmpage, vmpage->mapping->host->i_ino,
427 vmpage->mapping->host->i_generation,
428 vmpage->mapping->host, vmpage->index,
431 seq_page_flag(seq, vmpage, locked, has_flags);
432 seq_page_flag(seq, vmpage, error, has_flags);
433 seq_page_flag(seq, vmpage, referenced, has_flags);
434 seq_page_flag(seq, vmpage, uptodate, has_flags);
435 seq_page_flag(seq, vmpage, dirty, has_flags);
436 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,12))
437 seq_page_flag(seq, vmpage, highmem, has_flags);
439 seq_page_flag(seq, vmpage, writeback, has_flags);
440 seq_printf(seq, "%s]\n", has_flags ? "" : "-");
443 static int vvp_pgcache_show(struct seq_file *f, void *v)
446 struct ll_sb_info *sbi;
447 struct cl_object *clob;
449 struct cl_page *page;
450 struct cl_object_header *hdr;
451 struct vvp_pgcache_id id;
455 env = cl_env_get(&refcheck);
458 vvp_pgcache_id_unpack(pos, &id);
460 clob = vvp_pgcache_obj(env, &sbi->ll_cl->cd_lu_dev, &id);
462 hdr = cl_object_header(clob);
464 cfs_spin_lock(&hdr->coh_page_guard);
465 page = cl_page_lookup(hdr, id.vpi_index);
466 cfs_spin_unlock(&hdr->coh_page_guard);
468 seq_printf(f, "%8x@"DFID": ",
469 id.vpi_index, PFID(&hdr->coh_lu.loh_fid));
471 vvp_pgcache_page_show(env, f, page);
472 cl_page_put(env, page);
474 seq_puts(f, "missing\n");
475 lu_object_ref_del(&clob->co_lu, "dump", cfs_current());
476 cl_object_put(env, clob);
478 seq_printf(f, "%llx missing\n", pos);
479 cl_env_put(env, &refcheck);
482 result = PTR_ERR(env);
486 static void *vvp_pgcache_start(struct seq_file *f, loff_t *pos)
488 struct ll_sb_info *sbi;
494 env = cl_env_get(&refcheck);
497 if (sbi->ll_site->ls_hash_bits > 64 - PGC_OBJ_SHIFT)
498 pos = ERR_PTR(-EFBIG);
500 *pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev,
505 cl_env_put(env, &refcheck);
510 static void *vvp_pgcache_next(struct seq_file *f, void *v, loff_t *pos)
512 struct ll_sb_info *sbi;
516 env = cl_env_get(&refcheck);
519 *pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev, *pos + 1);
522 cl_env_put(env, &refcheck);
527 static void vvp_pgcache_stop(struct seq_file *f, void *v)
532 static struct seq_operations vvp_pgcache_ops = {
533 .start = vvp_pgcache_start,
534 .next = vvp_pgcache_next,
535 .stop = vvp_pgcache_stop,
536 .show = vvp_pgcache_show
539 static int vvp_dump_pgcache_seq_open(struct inode *inode, struct file *filp)
541 struct proc_dir_entry *dp = PDE(inode);
542 struct ll_sb_info *sbi = dp->data;
543 struct seq_file *seq;
546 result = seq_open(filp, &vvp_pgcache_ops);
548 seq = filp->private_data;
554 struct file_operations vvp_dump_pgcache_file_ops = {
555 .owner = THIS_MODULE,
556 .open = vvp_dump_pgcache_seq_open,
559 .release = seq_release,