inode.c 11.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * Persistent Storage - ramfs parts.
 *
 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/fsnotify.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
27
#include <linux/list.h>
28
29
#include <linux/string.h>
#include <linux/mount.h>
30
#include <linux/seq_file.h>
31
#include <linux/ramfs.h>
32
#include <linux/parser.h>
33
34
35
36
#include <linux/sched.h>
#include <linux/magic.h>
#include <linux/pstore.h>
#include <linux/slab.h>
37
#include <linux/spinlock.h>
38
39
40
41
42
43
#include <linux/uaccess.h>

#include "internal.h"

#define	PSTORE_NAMELEN	64

44
45
46
static DEFINE_SPINLOCK(allpstore_lock);
static LIST_HEAD(allpstore);

47
struct pstore_private {
48
	struct list_head list;
49
50
	struct pstore_record *record;
	size_t total_size;
51
52
};

53
54
55
56
57
58
59
60
struct pstore_ftrace_seq_data {
	const void *ptr;
	size_t off;
	size_t size;
};

#define REC_SIZE sizeof(struct pstore_ftrace_record)

61
62
63
64
static void free_pstore_private(struct pstore_private *private)
{
	if (!private)
		return;
65
66
67
68
	if (private->record) {
		kfree(private->record->buf);
		kfree(private->record);
	}
69
70
71
	kfree(private);
}

72
73
74
75
76
77
78
79
80
static void *pstore_ftrace_seq_start(struct seq_file *s, loff_t *pos)
{
	struct pstore_private *ps = s->private;
	struct pstore_ftrace_seq_data *data;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return NULL;

81
	data->off = ps->total_size % REC_SIZE;
82
	data->off += *pos * REC_SIZE;
83
	if (data->off + REC_SIZE > ps->total_size) {
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
		kfree(data);
		return NULL;
	}

	return data;

}

static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
{
	kfree(v);
}

static void *pstore_ftrace_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
	struct pstore_private *ps = s->private;
	struct pstore_ftrace_seq_data *data = v;

	data->off += REC_SIZE;
103
	if (data->off + REC_SIZE > ps->total_size)
104
105
106
107
108
109
110
111
112
113
		return NULL;

	(*pos)++;
	return data;
}

static int pstore_ftrace_seq_show(struct seq_file *s, void *v)
{
	struct pstore_private *ps = s->private;
	struct pstore_ftrace_seq_data *data = v;
114
115
116
	struct pstore_ftrace_record *rec;

	rec = (struct pstore_ftrace_record *)(ps->record->buf + data->off);
117

118
119
120
121
122
	seq_printf(s, "CPU:%d ts:%llu %08lx  %08lx  %pf <- %pF\n",
		   pstore_ftrace_decode_cpu(rec),
		   pstore_ftrace_read_timestamp(rec),
		   rec->ip, rec->parent_ip, (void *)rec->ip,
		   (void *)rec->parent_ip);
123
124
125
126
127
128
129
130
131
132
133

	return 0;
}

static const struct seq_operations pstore_ftrace_seq_ops = {
	.start	= pstore_ftrace_seq_start,
	.next	= pstore_ftrace_seq_next,
	.stop	= pstore_ftrace_seq_stop,
	.show	= pstore_ftrace_seq_show,
};

Tony Luck's avatar
Tony Luck committed
134
135
136
static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
						size_t count, loff_t *ppos)
{
137
138
	struct seq_file *sf = file->private_data;
	struct pstore_private *ps = sf->private;
Tony Luck's avatar
Tony Luck committed
139

140
	if (ps->record->type == PSTORE_TYPE_FTRACE)
141
		return seq_read(file, userbuf, count, ppos);
142
143
	return simple_read_from_buffer(userbuf, count, ppos,
				       ps->record->buf, ps->total_size);
Tony Luck's avatar
Tony Luck committed
144
145
}

146
147
148
149
150
151
152
static int pstore_file_open(struct inode *inode, struct file *file)
{
	struct pstore_private *ps = inode->i_private;
	struct seq_file *sf;
	int err;
	const struct seq_operations *sops = NULL;

153
	if (ps->record->type == PSTORE_TYPE_FTRACE)
154
155
156
157
158
159
160
161
162
163
164
165
		sops = &pstore_ftrace_seq_ops;

	err = seq_open(file, sops);
	if (err < 0)
		return err;

	sf = file->private_data;
	sf->private = ps;

	return 0;
}

166
static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence)
167
168
169
170
{
	struct seq_file *sf = file->private_data;

	if (sf->op)
171
172
		return seq_lseek(file, off, whence);
	return default_llseek(file, off, whence);
173
174
}

Tony Luck's avatar
Tony Luck committed
175
static const struct file_operations pstore_file_operations = {
176
177
178
179
	.open		= pstore_file_open,
	.read		= pstore_file_read,
	.llseek		= pstore_file_llseek,
	.release	= seq_release,
Tony Luck's avatar
Tony Luck committed
180
};
181
182
183
184
185
186
187

/*
 * When a file is unlinked from our file system we call the
 * platform driver to erase the record from persistent store.
 */
static int pstore_unlink(struct inode *dir, struct dentry *dentry)
{
188
	struct pstore_private *p = d_inode(dentry)->i_private;
189
	struct pstore_record *record = p->record;
190

191
	if (!record->psi->erase)
192
		return -EPERM;
193
194
195
196

	mutex_lock(&record->psi->read_mutex);
	record->psi->erase(record);
	mutex_unlock(&record->psi->read_mutex);
197
198
199
200

	return simple_unlink(dir, dentry);
}

Tony Luck's avatar
Tony Luck committed
201
202
static void pstore_evict_inode(struct inode *inode)
{
203
204
205
	struct pstore_private	*p = inode->i_private;
	unsigned long		flags;

206
	clear_inode(inode);
207
208
209
210
	if (p) {
		spin_lock_irqsave(&allpstore_lock, flags);
		list_del(&p->list);
		spin_unlock_irqrestore(&allpstore_lock, flags);
211
		free_pstore_private(p);
212
	}
Tony Luck's avatar
Tony Luck committed
213
214
}

215
216
217
218
219
static const struct inode_operations pstore_dir_inode_operations = {
	.lookup		= simple_lookup,
	.unlink		= pstore_unlink,
};

Al Viro's avatar
Al Viro committed
220
static struct inode *pstore_get_inode(struct super_block *sb)
Tony Luck's avatar
Tony Luck committed
221
222
223
224
{
	struct inode *inode = new_inode(sb);
	if (inode) {
		inode->i_ino = get_next_ino();
225
		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Tony Luck's avatar
Tony Luck committed
226
227
228
229
	}
	return inode;
}

230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
enum {
	Opt_kmsg_bytes, Opt_err
};

static const match_table_t tokens = {
	{Opt_kmsg_bytes, "kmsg_bytes=%u"},
	{Opt_err, NULL}
};

static void parse_options(char *options)
{
	char		*p;
	substring_t	args[MAX_OPT_ARGS];
	int		option;

	if (!options)
		return;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;

		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_kmsg_bytes:
			if (!match_int(&args[0], &option))
				pstore_set_kmsg_bytes(option);
			break;
		}
	}
}

David Howells's avatar
David Howells committed
264
265
266
267
268
269
270
271
272
273
/*
 * Display the mount options in /proc/mounts.
 */
static int pstore_show_options(struct seq_file *m, struct dentry *root)
{
	if (kmsg_bytes != PSTORE_DEFAULT_KMSG_BYTES)
		seq_printf(m, ",kmsg_bytes=%lu", kmsg_bytes);
	return 0;
}

274
275
static int pstore_remount(struct super_block *sb, int *flags, char *data)
{
276
	sync_filesystem(sb);
277
278
279
280
281
	parse_options(data);

	return 0;
}

282
283
284
static const struct super_operations pstore_ops = {
	.statfs		= simple_statfs,
	.drop_inode	= generic_delete_inode,
Tony Luck's avatar
Tony Luck committed
285
	.evict_inode	= pstore_evict_inode,
286
	.remount_fs	= pstore_remount,
David Howells's avatar
David Howells committed
287
	.show_options	= pstore_show_options,
288
289
290
291
};

static struct super_block *pstore_sb;

292
bool pstore_is_mounted(void)
293
{
Tony Luck's avatar
Tony Luck committed
294
	return pstore_sb != NULL;
295
296
297
298
299
300
301
}

/*
 * Make a regular file in the root directory of our file system.
 * Load it up with "size" bytes of data from "buf".
 * Set the mtime & ctime to the date that this record was originally stored.
 */
302
int pstore_mkfile(struct dentry *root, struct pstore_record *record)
303
304
305
{
	struct dentry		*dentry;
	struct inode		*inode;
306
	int			rc = 0;
307
	char			name[PSTORE_NAMELEN];
308
309
	struct pstore_private	*private, *pos;
	unsigned long		flags;
310
	size_t			size = record->size + record->ecc_notice_size;
311

312
313
	WARN_ON(!inode_is_locked(d_inode(root)));

314
315
	spin_lock_irqsave(&allpstore_lock, flags);
	list_for_each_entry(pos, &allpstore, list) {
316
317
318
		if (pos->record->type == record->type &&
		    pos->record->id == record->id &&
		    pos->record->psi == record->psi) {
319
320
321
322
323
324
325
			rc = -EEXIST;
			break;
		}
	}
	spin_unlock_irqrestore(&allpstore_lock, flags);
	if (rc)
		return rc;
326
327

	rc = -ENOMEM;
328
	inode = pstore_get_inode(root->d_sb);
329
330
	if (!inode)
		goto fail;
Al Viro's avatar
Al Viro committed
331
332
	inode->i_mode = S_IFREG | 0444;
	inode->i_fop = &pstore_file_operations;
333
	private = kzalloc(sizeof(*private), GFP_KERNEL);
334
335
	if (!private)
		goto fail_alloc;
336
	private->record = record;
337

338
	switch (record->type) {
339
	case PSTORE_TYPE_DMESG:
340
		scnprintf(name, sizeof(name), "dmesg-%s-%llu%s",
341
342
			  record->psi->name, record->id,
			  record->compressed ? ".enc.z" : "");
343
		break;
344
	case PSTORE_TYPE_CONSOLE:
345
		scnprintf(name, sizeof(name), "console-%s-%llu",
346
			  record->psi->name, record->id);
347
		break;
348
	case PSTORE_TYPE_FTRACE:
349
		scnprintf(name, sizeof(name), "ftrace-%s-%llu",
350
			  record->psi->name, record->id);
351
		break;
352
	case PSTORE_TYPE_MCE:
353
		scnprintf(name, sizeof(name), "mce-%s-%llu",
354
			  record->psi->name, record->id);
355
		break;
356
	case PSTORE_TYPE_PPC_RTAS:
357
		scnprintf(name, sizeof(name), "rtas-%s-%llu",
358
			  record->psi->name, record->id);
359
		break;
360
	case PSTORE_TYPE_PPC_OF:
361
		scnprintf(name, sizeof(name), "powerpc-ofw-%s-%llu",
362
			  record->psi->name, record->id);
363
		break;
364
	case PSTORE_TYPE_PPC_COMMON:
365
		scnprintf(name, sizeof(name), "powerpc-common-%s-%llu",
366
			  record->psi->name, record->id);
367
		break;
368
	case PSTORE_TYPE_PMSG:
369
		scnprintf(name, sizeof(name), "pmsg-%s-%llu",
370
			  record->psi->name, record->id);
371
		break;
372
	case PSTORE_TYPE_PPC_OPAL:
373
		scnprintf(name, sizeof(name), "powerpc-opal-%s-%llu",
374
			  record->psi->name, record->id);
375
		break;
376
	case PSTORE_TYPE_UNKNOWN:
377
		scnprintf(name, sizeof(name), "unknown-%s-%llu",
378
			  record->psi->name, record->id);
379
380
		break;
	default:
381
		scnprintf(name, sizeof(name), "type%d-%s-%llu",
382
			  record->type, record->psi->name, record->id);
383
384
385
386
		break;
	}

	dentry = d_alloc_name(root, name);
387
	if (!dentry)
388
		goto fail_private;
389

390
	inode->i_size = private->total_size = size;
391
392
393

	inode->i_private = private;

394
395
	if (record->time.tv_sec)
		inode->i_mtime = inode->i_ctime = record->time;
396

Tony Luck's avatar
Tony Luck committed
397
	d_add(dentry, inode);
398

399
400
401
402
	spin_lock_irqsave(&allpstore_lock, flags);
	list_add(&private->list, &allpstore);
	spin_unlock_irqrestore(&allpstore_lock, flags);

Tony Luck's avatar
Tony Luck committed
403
	return 0;
404

405
fail_private:
406
	free_pstore_private(private);
407
408
409
410
411
412
413
fail_alloc:
	iput(inode);

fail:
	return rc;
}

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
/*
 * Read all the records from the persistent store. Create
 * files in our filesystem.  Don't warn about -EEXIST errors
 * when we are re-scanning the backing store looking to add new
 * error records.
 */
void pstore_get_records(int quiet)
{
	struct pstore_info *psi = psinfo;
	struct dentry *root;

	if (!psi || !pstore_sb)
		return;

	root = pstore_sb->s_root;

	inode_lock(d_inode(root));
	pstore_get_backend_records(psi, root, quiet);
	inode_unlock(d_inode(root));
}

435
static int pstore_fill_super(struct super_block *sb, void *data, int silent)
436
{
437
	struct inode *inode;
438
439
440
441

	pstore_sb = sb;

	sb->s_maxbytes		= MAX_LFS_FILESIZE;
442
443
	sb->s_blocksize		= PAGE_SIZE;
	sb->s_blocksize_bits	= PAGE_SHIFT;
444
445
446
447
	sb->s_magic		= PSTOREFS_MAGIC;
	sb->s_op		= &pstore_ops;
	sb->s_time_gran		= 1;

448
449
	parse_options(data);

Al Viro's avatar
Al Viro committed
450
	inode = pstore_get_inode(sb);
451
	if (inode) {
452
		inode->i_mode = S_IFDIR | 0750;
453
		inode->i_op = &pstore_dir_inode_operations;
Al Viro's avatar
Al Viro committed
454
455
		inode->i_fop = &simple_dir_operations;
		inc_nlink(inode);
456
	}
457
458
459
	sb->s_root = d_make_root(inode);
	if (!sb->s_root)
		return -ENOMEM;
460

461
	pstore_get_records(0);
462
463
464
465

	return 0;
}

Tony Luck's avatar
Tony Luck committed
466
467
static struct dentry *pstore_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
468
{
Tony Luck's avatar
Tony Luck committed
469
	return mount_single(fs_type, flags, data, pstore_fill_super);
470
471
472
473
474
475
476
477
478
}

static void pstore_kill_sb(struct super_block *sb)
{
	kill_litter_super(sb);
	pstore_sb = NULL;
}

static struct file_system_type pstore_fs_type = {
Geliang Tang's avatar
Geliang Tang committed
479
	.owner          = THIS_MODULE,
480
	.name		= "pstore",
Tony Luck's avatar
Tony Luck committed
481
	.mount		= pstore_mount,
482
483
484
485
486
	.kill_sb	= pstore_kill_sb,
};

static int __init init_pstore_fs(void)
{
487
	int err;
488
489

	/* Create a convenient mount point for people to access pstore */
490
491
	err = sysfs_create_mount_point(fs_kobj, "pstore");
	if (err)
492
493
494
495
		goto out;

	err = register_filesystem(&pstore_fs_type);
	if (err < 0)
496
		sysfs_remove_mount_point(fs_kobj, "pstore");
497
498
499

out:
	return err;
500
501
502
}
module_init(init_pstore_fs)

Geliang Tang's avatar
Geliang Tang committed
503
504
505
506
507
508
509
static void __exit exit_pstore_fs(void)
{
	unregister_filesystem(&pstore_fs_type);
	sysfs_remove_mount_point(fs_kobj, "pstore");
}
module_exit(exit_pstore_fs)

510
511
MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
MODULE_LICENSE("GPL");