1/*
2 * GPL HEADER START
3 *
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19 *
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
22 * have any questions.
23 *
24 * GPL HEADER END
25 */
26/*
27 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
29 *
30 * Copyright (c) 2012, Intel Corporation.
31 */
32/*
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
35 *
36 * cl_device and cl_device_type implementation for VVP layer.
37 *
38 *   Author: Nikita Danilov <nikita.danilov@sun.com>
39 */
40
41#define DEBUG_SUBSYSTEM S_LLITE
42
43
44#include "../include/obd.h"
45#include "../include/lustre_lite.h"
46#include "llite_internal.h"
47#include "vvp_internal.h"
48
49/*****************************************************************************
50 *
51 * Vvp device and device type functions.
52 *
53 */
54
55/*
56 * vvp_ prefix stands for "Vfs Vm Posix". It corresponds to historical
57 * "llite_" (var. "ll_") prefix.
58 */
59
60static struct kmem_cache *vvp_thread_kmem;
61static struct kmem_cache *vvp_session_kmem;
62static struct lu_kmem_descr vvp_caches[] = {
63	{
64		.ckd_cache = &vvp_thread_kmem,
65		.ckd_name  = "vvp_thread_kmem",
66		.ckd_size  = sizeof (struct vvp_thread_info),
67	},
68	{
69		.ckd_cache = &vvp_session_kmem,
70		.ckd_name  = "vvp_session_kmem",
71		.ckd_size  = sizeof (struct vvp_session)
72	},
73	{
74		.ckd_cache = NULL
75	}
76};
77
78static void *vvp_key_init(const struct lu_context *ctx,
79			  struct lu_context_key *key)
80{
81	struct vvp_thread_info *info;
82
83	OBD_SLAB_ALLOC_PTR_GFP(info, vvp_thread_kmem, GFP_NOFS);
84	if (info == NULL)
85		info = ERR_PTR(-ENOMEM);
86	return info;
87}
88
89static void vvp_key_fini(const struct lu_context *ctx,
90			 struct lu_context_key *key, void *data)
91{
92	struct vvp_thread_info *info = data;
93	OBD_SLAB_FREE_PTR(info, vvp_thread_kmem);
94}
95
96static void *vvp_session_key_init(const struct lu_context *ctx,
97				  struct lu_context_key *key)
98{
99	struct vvp_session *session;
100
101	OBD_SLAB_ALLOC_PTR_GFP(session, vvp_session_kmem, GFP_NOFS);
102	if (session == NULL)
103		session = ERR_PTR(-ENOMEM);
104	return session;
105}
106
107static void vvp_session_key_fini(const struct lu_context *ctx,
108				 struct lu_context_key *key, void *data)
109{
110	struct vvp_session *session = data;
111	OBD_SLAB_FREE_PTR(session, vvp_session_kmem);
112}
113
114
115struct lu_context_key vvp_key = {
116	.lct_tags = LCT_CL_THREAD,
117	.lct_init = vvp_key_init,
118	.lct_fini = vvp_key_fini
119};
120
121struct lu_context_key vvp_session_key = {
122	.lct_tags = LCT_SESSION,
123	.lct_init = vvp_session_key_init,
124	.lct_fini = vvp_session_key_fini
125};
126
127/* type constructor/destructor: vvp_type_{init,fini,start,stop}(). */
128LU_TYPE_INIT_FINI(vvp, &ccc_key, &ccc_session_key, &vvp_key, &vvp_session_key);
129
130static const struct lu_device_operations vvp_lu_ops = {
131	.ldo_object_alloc      = vvp_object_alloc
132};
133
134static const struct cl_device_operations vvp_cl_ops = {
135	.cdo_req_init = ccc_req_init
136};
137
138static struct lu_device *vvp_device_alloc(const struct lu_env *env,
139					  struct lu_device_type *t,
140					  struct lustre_cfg *cfg)
141{
142	return ccc_device_alloc(env, t, cfg, &vvp_lu_ops, &vvp_cl_ops);
143}
144
145static const struct lu_device_type_operations vvp_device_type_ops = {
146	.ldto_init = vvp_type_init,
147	.ldto_fini = vvp_type_fini,
148
149	.ldto_start = vvp_type_start,
150	.ldto_stop  = vvp_type_stop,
151
152	.ldto_device_alloc = vvp_device_alloc,
153	.ldto_device_free  = ccc_device_free,
154	.ldto_device_init  = ccc_device_init,
155	.ldto_device_fini  = ccc_device_fini
156};
157
158struct lu_device_type vvp_device_type = {
159	.ldt_tags     = LU_DEVICE_CL,
160	.ldt_name     = LUSTRE_VVP_NAME,
161	.ldt_ops      = &vvp_device_type_ops,
162	.ldt_ctx_tags = LCT_CL_THREAD
163};
164
165/**
166 * A mutex serializing calls to vvp_inode_fini() under extreme memory
167 * pressure, when environments cannot be allocated.
168 */
169int vvp_global_init(void)
170{
171	int result;
172
173	result = lu_kmem_init(vvp_caches);
174	if (result == 0) {
175		result = ccc_global_init(&vvp_device_type);
176		if (result != 0)
177			lu_kmem_fini(vvp_caches);
178	}
179	return result;
180}
181
182void vvp_global_fini(void)
183{
184	ccc_global_fini(&vvp_device_type);
185	lu_kmem_fini(vvp_caches);
186}
187
188
189/*****************************************************************************
190 *
191 * mirror obd-devices into cl devices.
192 *
193 */
194
195int cl_sb_init(struct super_block *sb)
196{
197	struct ll_sb_info *sbi;
198	struct cl_device  *cl;
199	struct lu_env     *env;
200	int rc = 0;
201	int refcheck;
202
203	sbi  = ll_s2sbi(sb);
204	env = cl_env_get(&refcheck);
205	if (!IS_ERR(env)) {
206		cl = cl_type_setup(env, NULL, &vvp_device_type,
207				   sbi->ll_dt_exp->exp_obd->obd_lu_dev);
208		if (!IS_ERR(cl)) {
209			cl2ccc_dev(cl)->cdv_sb = sb;
210			sbi->ll_cl = cl;
211			sbi->ll_site = cl2lu_dev(cl)->ld_site;
212		}
213		cl_env_put(env, &refcheck);
214	} else
215		rc = PTR_ERR(env);
216	return rc;
217}
218
219int cl_sb_fini(struct super_block *sb)
220{
221	struct ll_sb_info *sbi;
222	struct lu_env     *env;
223	struct cl_device  *cld;
224	int		refcheck;
225	int		result;
226
227	sbi = ll_s2sbi(sb);
228	env = cl_env_get(&refcheck);
229	if (!IS_ERR(env)) {
230		cld = sbi->ll_cl;
231
232		if (cld != NULL) {
233			cl_stack_fini(env, cld);
234			sbi->ll_cl = NULL;
235			sbi->ll_site = NULL;
236		}
237		cl_env_put(env, &refcheck);
238		result = 0;
239	} else {
240		CERROR("Cannot cleanup cl-stack due to memory shortage.\n");
241		result = PTR_ERR(env);
242	}
243	/*
244	 * If mount failed (sbi->ll_cl == NULL), and this there are no other
245	 * mounts, stop device types manually (this usually happens
246	 * automatically when last device is destroyed).
247	 */
248	lu_types_stop();
249	return result;
250}
251
252/****************************************************************************
253 *
254 * /proc/fs/lustre/llite/$MNT/dump_page_cache
255 *
256 ****************************************************************************/
257
258/*
259 * To represent contents of a page cache as a byte stream, following
260 * information if encoded in 64bit offset:
261 *
262 *       - file hash bucket in lu_site::ls_hash[]       28bits
263 *
264 *       - how far file is from bucket head	      4bits
265 *
266 *       - page index				   32bits
267 *
268 * First two data identify a file in the cache uniquely.
269 */
270
271#define PGC_OBJ_SHIFT (32 + 4)
272#define PGC_DEPTH_SHIFT (32)
273
274struct vvp_pgcache_id {
275	unsigned		 vpi_bucket;
276	unsigned		 vpi_depth;
277	uint32_t		 vpi_index;
278
279	unsigned		 vpi_curdep;
280	struct lu_object_header *vpi_obj;
281};
282
283static void vvp_pgcache_id_unpack(loff_t pos, struct vvp_pgcache_id *id)
284{
285	CLASSERT(sizeof(pos) == sizeof(__u64));
286
287	id->vpi_index  = pos & 0xffffffff;
288	id->vpi_depth  = (pos >> PGC_DEPTH_SHIFT) & 0xf;
289	id->vpi_bucket = ((unsigned long long)pos >> PGC_OBJ_SHIFT);
290}
291
292static loff_t vvp_pgcache_id_pack(struct vvp_pgcache_id *id)
293{
294	return
295		((__u64)id->vpi_index) |
296		((__u64)id->vpi_depth  << PGC_DEPTH_SHIFT) |
297		((__u64)id->vpi_bucket << PGC_OBJ_SHIFT);
298}
299
300static int vvp_pgcache_obj_get(struct cfs_hash *hs, struct cfs_hash_bd *bd,
301			       struct hlist_node *hnode, void *data)
302{
303	struct vvp_pgcache_id   *id  = data;
304	struct lu_object_header *hdr = cfs_hash_object(hs, hnode);
305
306	if (id->vpi_curdep-- > 0)
307		return 0; /* continue */
308
309	if (lu_object_is_dying(hdr))
310		return 1;
311
312	cfs_hash_get(hs, hnode);
313	id->vpi_obj = hdr;
314	return 1;
315}
316
317static struct cl_object *vvp_pgcache_obj(const struct lu_env *env,
318					 struct lu_device *dev,
319					 struct vvp_pgcache_id *id)
320{
321	LASSERT(lu_device_is_cl(dev));
322
323	id->vpi_depth &= 0xf;
324	id->vpi_obj    = NULL;
325	id->vpi_curdep = id->vpi_depth;
326
327	cfs_hash_hlist_for_each(dev->ld_site->ls_obj_hash, id->vpi_bucket,
328				vvp_pgcache_obj_get, id);
329	if (id->vpi_obj != NULL) {
330		struct lu_object *lu_obj;
331
332		lu_obj = lu_object_locate(id->vpi_obj, dev->ld_type);
333		if (lu_obj != NULL) {
334			lu_object_ref_add(lu_obj, "dump", current);
335			return lu2cl(lu_obj);
336		}
337		lu_object_put(env, lu_object_top(id->vpi_obj));
338
339	} else if (id->vpi_curdep > 0) {
340		id->vpi_depth = 0xf;
341	}
342	return NULL;
343}
344
345static loff_t vvp_pgcache_find(const struct lu_env *env,
346			       struct lu_device *dev, loff_t pos)
347{
348	struct cl_object     *clob;
349	struct lu_site       *site;
350	struct vvp_pgcache_id id;
351
352	site = dev->ld_site;
353	vvp_pgcache_id_unpack(pos, &id);
354
355	while (1) {
356		if (id.vpi_bucket >= CFS_HASH_NHLIST(site->ls_obj_hash))
357			return ~0ULL;
358		clob = vvp_pgcache_obj(env, dev, &id);
359		if (clob != NULL) {
360			struct cl_object_header *hdr;
361			int		      nr;
362			struct cl_page	  *pg;
363
364			/* got an object. Find next page. */
365			hdr = cl_object_header(clob);
366
367			spin_lock(&hdr->coh_page_guard);
368			nr = radix_tree_gang_lookup(&hdr->coh_tree,
369						    (void **)&pg,
370						    id.vpi_index, 1);
371			if (nr > 0) {
372				id.vpi_index = pg->cp_index;
373				/* Cant support over 16T file */
374				nr = !(pg->cp_index > 0xffffffff);
375			}
376			spin_unlock(&hdr->coh_page_guard);
377
378			lu_object_ref_del(&clob->co_lu, "dump", current);
379			cl_object_put(env, clob);
380			if (nr > 0)
381				return vvp_pgcache_id_pack(&id);
382		}
383		/* to the next object. */
384		++id.vpi_depth;
385		id.vpi_depth &= 0xf;
386		if (id.vpi_depth == 0 && ++id.vpi_bucket == 0)
387			return ~0ULL;
388		id.vpi_index = 0;
389	}
390}
391
392#define seq_page_flag(seq, page, flag, has_flags) do {		  \
393	if (test_bit(PG_##flag, &(page)->flags)) {		  \
394		seq_printf(seq, "%s"#flag, has_flags ? "|" : "");       \
395		has_flags = 1;					  \
396	}							       \
397} while (0)
398
399static void vvp_pgcache_page_show(const struct lu_env *env,
400				  struct seq_file *seq, struct cl_page *page)
401{
402	struct ccc_page *cpg;
403	struct page      *vmpage;
404	int	      has_flags;
405
406	cpg = cl2ccc_page(cl_page_at(page, &vvp_device_type));
407	vmpage = cpg->cpg_page;
408	seq_printf(seq, " %5i | %p %p %s %s %s %s | %p %lu/%u(%p) %lu %u [",
409		   0 /* gen */,
410		   cpg, page,
411		   "none",
412		   cpg->cpg_write_queued ? "wq" : "- ",
413		   cpg->cpg_defer_uptodate ? "du" : "- ",
414		   PageWriteback(vmpage) ? "wb" : "-",
415		   vmpage, vmpage->mapping->host->i_ino,
416		   vmpage->mapping->host->i_generation,
417		   vmpage->mapping->host, vmpage->index,
418		   page_count(vmpage));
419	has_flags = 0;
420	seq_page_flag(seq, vmpage, locked, has_flags);
421	seq_page_flag(seq, vmpage, error, has_flags);
422	seq_page_flag(seq, vmpage, referenced, has_flags);
423	seq_page_flag(seq, vmpage, uptodate, has_flags);
424	seq_page_flag(seq, vmpage, dirty, has_flags);
425	seq_page_flag(seq, vmpage, writeback, has_flags);
426	seq_printf(seq, "%s]\n", has_flags ? "" : "-");
427}
428
429static int vvp_pgcache_show(struct seq_file *f, void *v)
430{
431	loff_t		   pos;
432	struct ll_sb_info       *sbi;
433	struct cl_object	*clob;
434	struct lu_env	   *env;
435	struct cl_page	  *page;
436	struct cl_object_header *hdr;
437	struct vvp_pgcache_id    id;
438	int		      refcheck;
439	int		      result;
440
441	env = cl_env_get(&refcheck);
442	if (!IS_ERR(env)) {
443		pos = *(loff_t *) v;
444		vvp_pgcache_id_unpack(pos, &id);
445		sbi = f->private;
446		clob = vvp_pgcache_obj(env, &sbi->ll_cl->cd_lu_dev, &id);
447		if (clob != NULL) {
448			hdr = cl_object_header(clob);
449
450			spin_lock(&hdr->coh_page_guard);
451			page = cl_page_lookup(hdr, id.vpi_index);
452			spin_unlock(&hdr->coh_page_guard);
453
454			seq_printf(f, "%8x@"DFID": ",
455				   id.vpi_index, PFID(&hdr->coh_lu.loh_fid));
456			if (page != NULL) {
457				vvp_pgcache_page_show(env, f, page);
458				cl_page_put(env, page);
459			} else
460				seq_puts(f, "missing\n");
461			lu_object_ref_del(&clob->co_lu, "dump", current);
462			cl_object_put(env, clob);
463		} else
464			seq_printf(f, "%llx missing\n", pos);
465		cl_env_put(env, &refcheck);
466		result = 0;
467	} else
468		result = PTR_ERR(env);
469	return result;
470}
471
472static void *vvp_pgcache_start(struct seq_file *f, loff_t *pos)
473{
474	struct ll_sb_info *sbi;
475	struct lu_env     *env;
476	int		refcheck;
477
478	sbi = f->private;
479
480	env = cl_env_get(&refcheck);
481	if (!IS_ERR(env)) {
482		sbi = f->private;
483		if (sbi->ll_site->ls_obj_hash->hs_cur_bits > 64 - PGC_OBJ_SHIFT)
484			pos = ERR_PTR(-EFBIG);
485		else {
486			*pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev,
487						*pos);
488			if (*pos == ~0ULL)
489				pos = NULL;
490		}
491		cl_env_put(env, &refcheck);
492	}
493	return pos;
494}
495
496static void *vvp_pgcache_next(struct seq_file *f, void *v, loff_t *pos)
497{
498	struct ll_sb_info *sbi;
499	struct lu_env     *env;
500	int		refcheck;
501
502	env = cl_env_get(&refcheck);
503	if (!IS_ERR(env)) {
504		sbi = f->private;
505		*pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev, *pos + 1);
506		if (*pos == ~0ULL)
507			pos = NULL;
508		cl_env_put(env, &refcheck);
509	}
510	return pos;
511}
512
513static void vvp_pgcache_stop(struct seq_file *f, void *v)
514{
515	/* Nothing to do */
516}
517
518static struct seq_operations vvp_pgcache_ops = {
519	.start = vvp_pgcache_start,
520	.next  = vvp_pgcache_next,
521	.stop  = vvp_pgcache_stop,
522	.show  = vvp_pgcache_show
523};
524
525static int vvp_dump_pgcache_seq_open(struct inode *inode, struct file *filp)
526{
527	struct ll_sb_info     *sbi = PDE_DATA(inode);
528	struct seq_file       *seq;
529	int		    result;
530
531	result = seq_open(filp, &vvp_pgcache_ops);
532	if (result == 0) {
533		seq = filp->private_data;
534		seq->private = sbi;
535	}
536	return result;
537}
538
539const struct file_operations vvp_dump_pgcache_file_ops = {
540	.owner   = THIS_MODULE,
541	.open    = vvp_dump_pgcache_seq_open,
542	.read    = seq_read,
543	.llseek	 = seq_lseek,
544	.release = seq_release,
545};
546