super.c 26.5 KB
Newer Older
1
2
/*
 * Copyright (C) 2005, 2006
Boaz Harrosh's avatar
Boaz Harrosh committed
3
 * Avishay Traeger (avishay@gmail.com)
4
 * Copyright (C) 2008, 2009
5
 * Boaz Harrosh <ooo@electrozaur.com>
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 *
 * Copyrights for code taken from ext2:
 *     Copyright (C) 1992, 1993, 1994, 1995
 *     Remy Card (card@masi.ibp.fr)
 *     Laboratoire MASI - Institut Blaise Pascal
 *     Universite Pierre et Marie Curie (Paris VI)
 *     from
 *     linux/fs/minix/inode.c
 *     Copyright (C) 1991, 1992  Linus Torvalds
 *
 * This file is part of exofs.
 *
 * exofs is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation.  Since it is based on ext2, and the only
 * valid version of GPL for the Linux kernel is version 2, the only valid
 * version of GPL for exofs is version 2.
 *
 * exofs 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 exofs; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <linux/string.h>
#include <linux/parser.h>
#include <linux/vfs.h>
#include <linux/random.h>
38
#include <linux/module.h>
Boaz Harrosh's avatar
Boaz Harrosh committed
39
#include <linux/exportfs.h>
40
#include <linux/slab.h>
41
#include <linux/iversion.h>
42
43
44

#include "exofs.h"

45
46
#define EXOFS_DBGMSG2(M...) do {} while (0)

47
48
49
50
51
52
53
54
/******************************************************************************
 * MOUNT OPTIONS
 *****************************************************************************/

/*
 * struct to hold what we get from mount options
 */
struct exofs_mountopt {
55
	bool is_osdname;
56
57
58
59
60
61
62
63
	const char *dev_name;
	uint64_t pid;
	int timeout;
};

/*
 * exofs-specific mount-time options.
 */
64
enum { Opt_name, Opt_pid, Opt_to, Opt_err };
65
66
67
68
69
70
71

/*
 * Our mount-time options.  These should ideally be 64-bit unsigned, but the
 * kernel's parsing functions do not currently support that.  32-bit should be
 * sufficient for most applications now.
 */
static match_table_t tokens = {
72
	{Opt_name, "osdname=%s"},
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
	{Opt_pid, "pid=%u"},
	{Opt_to, "to=%u"},
	{Opt_err, NULL}
};

/*
 * The main option parsing method.  Also makes sure that all of the mandatory
 * mount options were set.
 */
static int parse_options(char *options, struct exofs_mountopt *opts)
{
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;
	bool s_pid = false;

	EXOFS_DBGMSG("parse_options %s\n", options);
	/* defaults */
	memset(opts, 0, sizeof(*opts));
	opts->timeout = BLK_DEFAULT_SG_TIMEOUT;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		char str[32];

		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
103
104
105
106
107
108
109
110
		case Opt_name:
			opts->dev_name = match_strdup(&args[0]);
			if (unlikely(!opts->dev_name)) {
				EXOFS_ERR("Error allocating dev_name");
				return -ENOMEM;
			}
			opts->is_osdname = true;
			break;
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
		case Opt_pid:
			if (0 == match_strlcpy(str, &args[0], sizeof(str)))
				return -EINVAL;
			opts->pid = simple_strtoull(str, NULL, 0);
			if (opts->pid < EXOFS_MIN_PID) {
				EXOFS_ERR("Partition ID must be >= %u",
					  EXOFS_MIN_PID);
				return -EINVAL;
			}
			s_pid = 1;
			break;
		case Opt_to:
			if (match_int(&args[0], &option))
				return -EINVAL;
			if (option <= 0) {
Masanari Iida's avatar
Masanari Iida committed
126
				EXOFS_ERR("Timeout must be > 0");
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
				return -EINVAL;
			}
			opts->timeout = option * HZ;
			break;
		}
	}

	if (!s_pid) {
		EXOFS_ERR("Need to specify the following options:\n");
		EXOFS_ERR("    -o pid=pid_no_to_use\n");
		return -EINVAL;
	}

	return 0;
}

/******************************************************************************
 * INODE CACHE
 *****************************************************************************/

/*
 * Our inode cache.  Isn't it pretty?
 */
static struct kmem_cache *exofs_inode_cachep;

/*
 * Allocate an inode in the cache
 */
static struct inode *exofs_alloc_inode(struct super_block *sb)
{
	struct exofs_i_info *oi;

	oi = kmem_cache_alloc(exofs_inode_cachep, GFP_KERNEL);
	if (!oi)
		return NULL;

163
	inode_set_iversion(&oi->vfs_inode, 1);
164
165
166
	return &oi->vfs_inode;
}

Nick Piggin's avatar
Nick Piggin committed
167
168
169
170
171
172
static void exofs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	kmem_cache_free(exofs_inode_cachep, exofs_i(inode));
}

173
174
175
176
177
/*
 * Remove an inode from the cache
 */
static void exofs_destroy_inode(struct inode *inode)
{
Nick Piggin's avatar
Nick Piggin committed
178
	call_rcu(&inode->i_rcu, exofs_i_callback);
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
}

/*
 * Initialize the inode
 */
static void exofs_init_once(void *foo)
{
	struct exofs_i_info *oi = foo;

	inode_init_once(&oi->vfs_inode);
}

/*
 * Create and initialize the inode cache
 */
static int init_inodecache(void)
{
196
	exofs_inode_cachep = kmem_cache_create_usercopy("exofs_inode_cache",
197
				sizeof(struct exofs_i_info), 0,
198
				SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
199
200
201
202
				SLAB_ACCOUNT,
				offsetof(struct exofs_i_info, i_data),
				sizeof_field(struct exofs_i_info, i_data),
				exofs_init_once);
203
204
205
206
207
208
209
210
211
212
	if (exofs_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

/*
 * Destroy the inode cache
 */
static void destroy_inodecache(void)
{
213
214
215
216
217
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
218
219
220
221
	kmem_cache_destroy(exofs_inode_cachep);
}

/******************************************************************************
222
 * Some osd helpers
223
 *****************************************************************************/
224
225
226
227
228
229
230
231
void exofs_make_credential(u8 cred_a[OSD_CAP_LEN], const struct osd_obj_id *obj)
{
	osd_sec_init_nosec_doall_caps(cred_a, obj, false, true);
}

static int exofs_read_kern(struct osd_dev *od, u8 *cred, struct osd_obj_id *obj,
		    u64 offset, void *p, unsigned length)
{
232
	struct osd_request *or = osd_start_request(od);
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
264
/*	struct osd_sense_info osi = {.key = 0};*/
	int ret;

	if (unlikely(!or)) {
		EXOFS_DBGMSG("%s: osd_start_request failed.\n", __func__);
		return -ENOMEM;
	}
	ret = osd_req_read_kern(or, obj, offset, p, length);
	if (unlikely(ret)) {
		EXOFS_DBGMSG("%s: osd_req_read_kern failed.\n", __func__);
		goto out;
	}

	ret = osd_finalize_request(or, 0, cred, NULL);
	if (unlikely(ret)) {
		EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n", ret);
		goto out;
	}

	ret = osd_execute_request(or);
	if (unlikely(ret))
		EXOFS_DBGMSG("osd_execute_request() => %d\n", ret);
	/* osd_req_decode_sense(or, ret); */

out:
	osd_end_request(or);
	EXOFS_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
		      "length=0x%llx dev=%p ret=>%d\n",
		      _LLU(obj->id), _LLU(offset), _LLU(length), od, ret);
	return ret;
}

265
266
267
268
269
270
271
272
273
274
static const struct osd_attr g_attr_sb_stats = ATTR_DEF(
	EXOFS_APAGE_SB_DATA,
	EXOFS_ATTR_SB_STATS,
	sizeof(struct exofs_sb_stats));

static int __sbi_read_stats(struct exofs_sb_info *sbi)
{
	struct osd_attr attrs[] = {
		[0] = g_attr_sb_stats,
	};
275
	struct ore_io_state *ios;
276
277
	int ret;

278
	ret = ore_get_io_state(&sbi->layout, &sbi->oc, &ios);
279
	if (unlikely(ret)) {
280
		EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
281
282
283
284
285
286
		return ret;
	}

	ios->in_attr = attrs;
	ios->in_attr_len = ARRAY_SIZE(attrs);

287
	ret = ore_read(ios);
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
	if (unlikely(ret)) {
		EXOFS_ERR("Error reading super_block stats => %d\n", ret);
		goto out;
	}

	ret = extract_attr_from_ios(ios, &attrs[0]);
	if (ret) {
		EXOFS_ERR("%s: extract_attr of sb_stats failed\n", __func__);
		goto out;
	}
	if (attrs[0].len) {
		struct exofs_sb_stats *ess;

		if (unlikely(attrs[0].len != sizeof(*ess))) {
			EXOFS_ERR("%s: Wrong version of exofs_sb_stats "
				  "size(%d) != expected(%zd)\n",
				  __func__, attrs[0].len, sizeof(*ess));
			goto out;
		}

		ess = attrs[0].val_ptr;
		sbi->s_nextid = le64_to_cpu(ess->s_nextid);
		sbi->s_numfiles = le32_to_cpu(ess->s_numfiles);
	}

out:
314
	ore_put_io_state(ios);
315
316
317
	return ret;
}

318
static void stats_done(struct ore_io_state *ios, void *p)
319
{
320
	ore_put_io_state(ios);
321
322
323
324
325
326
327
328
329
	/* Good thanks nothing to do anymore */
}

/* Asynchronously write the stats attribute */
int exofs_sbi_write_stats(struct exofs_sb_info *sbi)
{
	struct osd_attr attrs[] = {
		[0] = g_attr_sb_stats,
	};
330
	struct ore_io_state *ios;
331
332
	int ret;

333
	ret = ore_get_io_state(&sbi->layout, &sbi->oc, &ios);
334
	if (unlikely(ret)) {
335
		EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
336
337
338
339
340
341
342
		return ret;
	}

	sbi->s_ess.s_nextid   = cpu_to_le64(sbi->s_nextid);
	sbi->s_ess.s_numfiles = cpu_to_le64(sbi->s_numfiles);
	attrs[0].val_ptr = &sbi->s_ess;

343

344
345
346
347
348
	ios->done = stats_done;
	ios->private = sbi;
	ios->out_attr = attrs;
	ios->out_attr_len = ARRAY_SIZE(attrs);

349
	ret = ore_write(ios);
350
	if (unlikely(ret)) {
351
352
		EXOFS_ERR("%s: ore_write failed.\n", __func__);
		ore_put_io_state(ios);
353
354
355
356
357
	}

	return ret;
}

358
359
360
361
362
363
/******************************************************************************
 * SUPERBLOCK FUNCTIONS
 *****************************************************************************/
static const struct super_operations exofs_sops;
static const struct export_operations exofs_export_ops;

364
365
366
/*
 * Write the superblock to the OSD
 */
367
static int exofs_sync_fs(struct super_block *sb, int wait)
368
369
370
{
	struct exofs_sb_info *sbi;
	struct exofs_fscb *fscb;
371
	struct ore_comp one_comp;
372
	struct ore_components oc;
373
	struct ore_io_state *ios;
Christoph Hellwig's avatar
Christoph Hellwig committed
374
	int ret = -ENOMEM;
375

376
377
378
379
	fscb = kmalloc(sizeof(*fscb), GFP_KERNEL);
	if (unlikely(!fscb))
		return -ENOMEM;

380
	sbi = sb->s_fs_info;
381

382
383
384
385
386
387
388
	/* NOTE: We no longer dirty the super_block anywhere in exofs. The
	 * reason we write the fscb here on unmount is so we can stay backwards
	 * compatible with fscb->s_version == 1. (What we are not compatible
	 * with is if a new version FS crashed and then we try to mount an old
	 * version). Otherwise the exofs_fscb is read-only from mkfs time. All
	 * the writeable info is set in exofs_sbi_write_stats() above.
	 */
389

390
	exofs_init_comps(&oc, &one_comp, sbi, EXOFS_SUPER_ID);
391

392
	ret = ore_get_io_state(&sbi->layout, &oc, &ios);
393
	if (unlikely(ret))
394
395
		goto out;

396
	ios->length = offsetof(struct exofs_fscb, s_dev_table_oid);
397
	memset(fscb, 0, ios->length);
398
	fscb->s_nextid = cpu_to_le64(sbi->s_nextid);
399
	fscb->s_numfiles = cpu_to_le64(sbi->s_numfiles);
400
401
	fscb->s_magic = cpu_to_le16(sb->s_magic);
	fscb->s_newfs = 0;
402
	fscb->s_version = EXOFS_FSCB_VER;
403

404
405
	ios->offset = 0;
	ios->kern_buff = fscb;
406

407
	ret = ore_write(ios);
408
	if (unlikely(ret))
409
		EXOFS_ERR("%s: ore_write failed.\n", __func__);
410

411
out:
412
	EXOFS_DBGMSG("s_nextid=0x%llx ret=%d\n", _LLU(sbi->s_nextid), ret);
413
	ore_put_io_state(ios);
414
	kfree(fscb);
Christoph Hellwig's avatar
Christoph Hellwig committed
415
416
417
	return ret;
}

418
419
420
421
422
423
424
425
426
static void _exofs_print_device(const char *msg, const char *dev_path,
				struct osd_dev *od, u64 pid)
{
	const struct osd_dev_info *odi = osduld_device_info(od);

	printk(KERN_NOTICE "exofs: %s %s osd_name-%s pid-0x%llx\n",
		msg, dev_path ?: "", odi->osdname, _LLU(pid));
}

427
static void exofs_free_sbi(struct exofs_sb_info *sbi)
428
{
429
430
431
432
433
	unsigned numdevs = sbi->oc.numdevs;

	while (numdevs) {
		unsigned i = --numdevs;
		struct osd_dev *od = ore_comp_dev(&sbi->oc, i);
434
435

		if (od) {
436
			ore_comp_set_dev(&sbi->oc, i, NULL);
437
438
439
			osduld_put_device(od);
		}
	}
440
	kfree(sbi->oc.ods);
441
442
443
	kfree(sbi);
}

444
445
446
447
448
449
450
451
452
453
454
455
456
/*
 * This function is called when the vfs is freeing the superblock.  We just
 * need to free our own part.
 */
static void exofs_put_super(struct super_block *sb)
{
	int num_pend;
	struct exofs_sb_info *sbi = sb->s_fs_info;

	/* make sure there are no pending commands */
	for (num_pend = atomic_read(&sbi->s_curr_pending); num_pend > 0;
	     num_pend = atomic_read(&sbi->s_curr_pending)) {
		wait_queue_head_t wq;
457
458
459
460

		printk(KERN_NOTICE "%s: !!Pending operations in flight. "
		       "This is a BUG. please report to osd-dev@open-osd.org\n",
		       __func__);
461
462
463
464
465
466
		init_waitqueue_head(&wq);
		wait_event_timeout(wq,
				  (atomic_read(&sbi->s_curr_pending) == 0),
				  msecs_to_jiffies(100));
	}

467
	_exofs_print_device("Unmounting", NULL, ore_comp_dev(&sbi->oc, 0),
468
			    sbi->one_comp.obj.partition);
469

470
	exofs_sysfs_sb_del(sbi);
471
	exofs_free_sbi(sbi);
472
473
474
	sb->s_fs_info = NULL;
}

475
476
477
static int _read_and_match_data_map(struct exofs_sb_info *sbi, unsigned numdevs,
				    struct exofs_device_table *dt)
{
478
	int ret;
Boaz Harrosh's avatar
Boaz Harrosh committed
479

480
	sbi->layout.stripe_unit =
481
				le64_to_cpu(dt->dt_data_map.cb_stripe_unit);
482
	sbi->layout.group_width =
483
				le32_to_cpu(dt->dt_data_map.cb_group_width);
484
	sbi->layout.group_depth =
485
				le32_to_cpu(dt->dt_data_map.cb_group_depth);
486
487
488
	sbi->layout.mirrors_p1  =
				le32_to_cpu(dt->dt_data_map.cb_mirror_cnt) + 1;
	sbi->layout.raid_algorithm  =
489
490
				le32_to_cpu(dt->dt_data_map.cb_raid_algorithm);

491
	ret = ore_verify_layout(numdevs, &sbi->layout);
Boaz Harrosh's avatar
Boaz Harrosh committed
492

Boaz Harrosh's avatar
Boaz Harrosh committed
493
494
495
496
497
498
499
500
	EXOFS_DBGMSG("exofs: layout: "
		"num_comps=%u stripe_unit=0x%x group_width=%u "
		"group_depth=0x%llx mirrors_p1=%u raid_algorithm=%u\n",
		numdevs,
		sbi->layout.stripe_unit,
		sbi->layout.group_width,
		_LLU(sbi->layout.group_depth),
		sbi->layout.mirrors_p1,
501
		sbi->layout.raid_algorithm);
502
	return ret;
503
504
}

505
static unsigned __ra_pages(struct ore_layout *layout)
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
{
	const unsigned _MIN_RA = 32; /* min 128K read-ahead */
	unsigned ra_pages = layout->group_width * layout->stripe_unit /
				PAGE_SIZE;
	unsigned max_io_pages = exofs_max_io_pages(layout, ~0);

	ra_pages *= 2; /* two stripes */
	if (ra_pages < _MIN_RA)
		ra_pages = roundup(_MIN_RA, ra_pages / 2);

	if (ra_pages > max_io_pages)
		ra_pages = max_io_pages;

	return ra_pages;
}

522
523
524
525
526
/* @odi is valid only as long as @fscb_dev is valid */
static int exofs_devs_2_odi(struct exofs_dt_device_info *dt_dev,
			     struct osd_dev_info *odi)
{
	odi->systemid_len = le32_to_cpu(dt_dev->systemid_len);
527
528
	if (likely(odi->systemid_len))
		memcpy(odi->systemid, dt_dev->systemid, OSD_SYSTEMID_LEN);
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548

	odi->osdname_len = le32_to_cpu(dt_dev->osdname_len);
	odi->osdname = dt_dev->osdname;

	/* FIXME support long names. Will need a _put function */
	if (dt_dev->long_name_offset)
		return -EINVAL;

	/* Make sure osdname is printable!
	 * mkexofs should give us space for a null-terminator else the
	 * device-table is invalid.
	 */
	if (unlikely(odi->osdname_len >= sizeof(dt_dev->osdname)))
		odi->osdname_len = sizeof(dt_dev->osdname) - 1;
	dt_dev->osdname[odi->osdname_len] = 0;

	/* If it's all zeros something is bad we read past end-of-obj */
	return !(odi->systemid_len || odi->osdname_len);
}

549
static int __alloc_dev_table(struct exofs_sb_info *sbi, unsigned numdevs,
550
551
		      struct exofs_dev **peds)
{
Kees Cook's avatar
Kees Cook committed
552
553
554
555
	/* Twice bigger table: See exofs_init_comps() and comment at
	 * exofs_read_lookup_dev_table()
	 */
	const size_t numores = numdevs * 2 - 1;
556
557
558
	struct exofs_dev *eds;
	unsigned i;

Kees Cook's avatar
Kees Cook committed
559
560
561
	sbi->oc.ods = kzalloc(numores * sizeof(struct ore_dev *) +
			      numdevs * sizeof(struct exofs_dev), GFP_KERNEL);
	if (unlikely(!sbi->oc.ods)) {
562
		EXOFS_ERR("ERROR: failed allocating Device array[%d]\n",
563
564
565
566
			  numdevs);
		return -ENOMEM;
	}

Kees Cook's avatar
Kees Cook committed
567
568
569
	/* Start of allocated struct exofs_dev entries */
	*peds = eds = (void *)sbi->oc.ods[numores];
	/* Initialize pointers into struct exofs_dev */
570
	for (i = 0; i < numdevs; ++i)
Kees Cook's avatar
Kees Cook committed
571
		sbi->oc.ods[i] = &eds[i].ored;
572
573
574
	return 0;
}

Boaz Harrosh's avatar
Boaz Harrosh committed
575
576
static int exofs_read_lookup_dev_table(struct exofs_sb_info *sbi,
				       struct osd_dev *fscb_od,
577
578
				       unsigned table_count)
{
579
	struct ore_comp comp;
580
	struct exofs_device_table *dt;
581
	struct exofs_dev *eds;
582
583
584
585
586
587
588
589
590
591
592
593
	unsigned table_bytes = table_count * sizeof(dt->dt_dev_table[0]) +
					     sizeof(*dt);
	unsigned numdevs, i;
	int ret;

	dt = kmalloc(table_bytes, GFP_KERNEL);
	if (unlikely(!dt)) {
		EXOFS_ERR("ERROR: allocating %x bytes for device table\n",
			  table_bytes);
		return -ENOMEM;
	}

594
	sbi->oc.numdevs = 0;
595
596
597
598
599
600
601

	comp.obj.partition = sbi->one_comp.obj.partition;
	comp.obj.id = EXOFS_DEVTABLE_ID;
	exofs_make_credential(comp.cred, &comp.obj);

	ret = exofs_read_kern(fscb_od, comp.cred, &comp.obj, 0, dt,
			      table_bytes);
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
	if (unlikely(ret)) {
		EXOFS_ERR("ERROR: reading device table\n");
		goto out;
	}

	numdevs = le64_to_cpu(dt->dt_num_devices);
	if (unlikely(!numdevs)) {
		ret = -EINVAL;
		goto out;
	}
	WARN_ON(table_count != numdevs);

	ret = _read_and_match_data_map(sbi, numdevs, dt);
	if (unlikely(ret))
		goto out;

618
619
620
621
622
623
624
625
626
627
	ret = __alloc_dev_table(sbi, numdevs, &eds);
	if (unlikely(ret))
		goto out;
	/* exofs round-robins the device table view according to inode
	 * number. We hold a: twice bigger table hence inodes can point
	 * to any device and have a sequential view of the table
	 * starting at this device. See exofs_init_comps()
	 */
	memcpy(&sbi->oc.ods[numdevs], &sbi->oc.ods[0],
		(numdevs - 1) * sizeof(sbi->oc.ods[0]));
628

629
630
631
632
633
634
	/* create sysfs subdir under which we put the device table
	 * And cluster layout. A Superblock is identified by the string:
	 *	"dev[0].osdname"_"pid"
	 */
	exofs_sysfs_sb_add(sbi, &dt->dt_dev_table[0]);

635
636
637
638
639
640
641
642
643
644
645
646
647
648
	for (i = 0; i < numdevs; i++) {
		struct exofs_fscb fscb;
		struct osd_dev_info odi;
		struct osd_dev *od;

		if (exofs_devs_2_odi(&dt->dt_dev_table[i], &odi)) {
			EXOFS_ERR("ERROR: Read all-zeros device entry\n");
			ret = -EINVAL;
			goto out;
		}

		printk(KERN_NOTICE "Add device[%d]: osd_name-%s\n",
		       i, odi.osdname);

649
650
651
		/* the exofs id is currently the table index */
		eds[i].did = i;

652
653
654
655
656
		/* On all devices the device table is identical. The user can
		 * specify any one of the participating devices on the command
		 * line. We always keep them in device-table order.
		 */
		if (fscb_od && osduld_device_same(fscb_od, &odi)) {
657
			eds[i].ored.od = fscb_od;
658
			++sbi->oc.numdevs;
659
			fscb_od = NULL;
660
			exofs_sysfs_odev_add(&eds[i], sbi);
661
662
663
664
			continue;
		}

		od = osduld_info_lookup(&odi);
665
		if (IS_ERR(od)) {
666
667
668
669
670
671
			ret = PTR_ERR(od);
			EXOFS_ERR("ERROR: device requested is not found "
				  "osd_name-%s =>%d\n", odi.osdname, ret);
			goto out;
		}

672
		eds[i].ored.od = od;
673
		++sbi->oc.numdevs;
674
675
676
677

		/* Read the fscb of the other devices to make sure the FS
		 * partition is there.
		 */
678
		ret = exofs_read_kern(od, comp.cred, &comp.obj, 0, &fscb,
679
680
681
682
683
684
685
				      sizeof(fscb));
		if (unlikely(ret)) {
			EXOFS_ERR("ERROR: Malformed participating device "
				  "error reading fscb osd_name-%s\n",
				  odi.osdname);
			goto out;
		}
686
		exofs_sysfs_odev_add(&eds[i], sbi);
687
688
689
690
691
692
693
694
695

		/* TODO: verify other information is correct and FS-uuid
		 *	 matches. Benny what did you say about device table
		 *	 generation and old devices?
		 */
	}

out:
	kfree(dt);
696
	if (unlikely(fscb_od && !ret)) {
697
698
699
700
			EXOFS_ERR("ERROR: Bad device-table container device not present\n");
			osduld_put_device(fscb_od);
			return -EINVAL;
	}
701
702
703
	return ret;
}

704
705
706
707
708
709
710
711
/*
 * Read the superblock from the OSD and fill in the fields
 */
static int exofs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *root;
	struct exofs_mountopt *opts = data;
	struct exofs_sb_info *sbi;	/*extended info                  */
712
	struct osd_dev *od;		/* Master device                 */
713
	struct exofs_fscb fscb;		/*on-disk superblock info        */
714
	struct ore_comp comp;
715
	unsigned table_count;
716
717
718
719
720
721
722
	int ret;

	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

	/* use mount options to fill superblock */
723
724
725
726
727
728
	if (opts->is_osdname) {
		struct osd_dev_info odi = {.systemid_len = 0};

		odi.osdname_len = strlen(opts->dev_name);
		odi.osdname = (u8 *)opts->dev_name;
		od = osduld_info_lookup(&odi);
729
730
		kfree(opts->dev_name);
		opts->dev_name = NULL;
731
732
733
	} else {
		od = osduld_path_lookup(opts->dev_name);
	}
734
	if (IS_ERR(od)) {
735
		ret = -EINVAL;
736
737
738
		goto free_sbi;
	}

739
	/* Default layout in case we do not have a device-table */
Boaz Harrosh's avatar
Boaz Harrosh committed
740
741
742
	sbi->layout.stripe_unit = PAGE_SIZE;
	sbi->layout.mirrors_p1 = 1;
	sbi->layout.group_width = 1;
Boaz Harrosh's avatar
Boaz Harrosh committed
743
744
	sbi->layout.group_depth = -1;
	sbi->layout.group_count = 1;
745
746
	sbi->s_timeout = opts->timeout;

747
748
749
	sbi->one_comp.obj.partition = opts->pid;
	sbi->one_comp.obj.id = 0;
	exofs_make_credential(sbi->one_comp.cred, &sbi->one_comp.obj);
750
751
	sbi->oc.single_comp = EC_SINGLE_COMP;
	sbi->oc.comps = &sbi->one_comp;
752

753
754
755
756
757
758
	/* fill in some other data by hand */
	memset(sb->s_id, 0, sizeof(sb->s_id));
	strcpy(sb->s_id, "exofs");
	sb->s_blocksize = EXOFS_BLKSIZE;
	sb->s_blocksize_bits = EXOFS_BLKSHIFT;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
759
	sb->s_max_links = EXOFS_LINK_MAX;
760
761
762
763
	atomic_set(&sbi->s_curr_pending, 0);
	sb->s_bdev = NULL;
	sb->s_dev = 0;

764
765
766
	comp.obj.partition = sbi->one_comp.obj.partition;
	comp.obj.id = EXOFS_SUPER_ID;
	exofs_make_credential(comp.cred, &comp.obj);
767

768
	ret = exofs_read_kern(od, comp.cred, &comp.obj, 0, &fscb, sizeof(fscb));
769
	if (unlikely(ret))
770
771
772
		goto free_sbi;

	sb->s_magic = le16_to_cpu(fscb.s_magic);
773
	/* NOTE: we read below to be backward compatible with old versions */
774
775
776
777
778
779
780
781
782
783
	sbi->s_nextid = le64_to_cpu(fscb.s_nextid);
	sbi->s_numfiles = le32_to_cpu(fscb.s_numfiles);

	/* make sure what we read from the object store is correct */
	if (sb->s_magic != EXOFS_SUPER_MAGIC) {
		if (!silent)
			EXOFS_ERR("ERROR: Bad magic value\n");
		ret = -EINVAL;
		goto free_sbi;
	}
784
	if (le32_to_cpu(fscb.s_version) > EXOFS_FSCB_VER) {
785
786
787
788
789
		EXOFS_ERR("ERROR: Bad FSCB version expected-%d got-%d\n",
			  EXOFS_FSCB_VER, le32_to_cpu(fscb.s_version));
		ret = -EINVAL;
		goto free_sbi;
	}
790
791
792
793
794

	/* start generation numbers from a random point */
	get_random_bytes(&sbi->s_next_generation, sizeof(u32));
	spin_lock_init(&sbi->s_next_gen_lock);

795
796
	table_count = le64_to_cpu(fscb.s_dev_table_count);
	if (table_count) {
Boaz Harrosh's avatar
Boaz Harrosh committed
797
		ret = exofs_read_lookup_dev_table(sbi, od, table_count);
798
799
		if (unlikely(ret))
			goto free_sbi;
Boaz Harrosh's avatar
Boaz Harrosh committed
800
	} else {
801
802
803
804
805
806
807
		struct exofs_dev *eds;

		ret = __alloc_dev_table(sbi, 1, &eds);
		if (unlikely(ret))
			goto free_sbi;

		ore_comp_set_dev(&sbi->oc, 0, od);
808
		sbi->oc.numdevs = 1;
809
810
	}

811
812
	__sbi_read_stats(sbi);

813
	/* set up operation vectors */
814
815
816
817
818
819
	ret = super_setup_bdi(sb);
	if (ret) {
		EXOFS_DBGMSG("Failed to super_setup_bdi\n");
		goto free_sbi;
	}
	sb->s_bdi->ra_pages = __ra_pages(&sbi->layout);
820
	sb->s_fs_info = sbi;
821
	sb->s_op = &exofs_sops;
Boaz Harrosh's avatar
Boaz Harrosh committed
822
	sb->s_export_op = &exofs_export_ops;
823
824
825
826
827
828
	root = exofs_iget(sb, EXOFS_ROOT_ID - EXOFS_OBJ_OFF);
	if (IS_ERR(root)) {
		EXOFS_ERR("ERROR: exofs_iget failed\n");
		ret = PTR_ERR(root);
		goto free_sbi;
	}
829
	sb->s_root = d_make_root(root);
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
	if (!sb->s_root) {
		EXOFS_ERR("ERROR: get root inode failed\n");
		ret = -ENOMEM;
		goto free_sbi;
	}

	if (!S_ISDIR(root->i_mode)) {
		dput(sb->s_root);
		sb->s_root = NULL;
		EXOFS_ERR("ERROR: corrupt root inode (mode = %hd)\n",
		       root->i_mode);
		ret = -EINVAL;
		goto free_sbi;
	}

845
	exofs_sysfs_dbg_print();
846
847
	_exofs_print_device("Mounting", opts->dev_name,
			    ore_comp_dev(&sbi->oc, 0),
848
			    sbi->one_comp.obj.partition);
849
	return 0;
850
851

free_sbi:
852
	EXOFS_ERR("Unable to mount exofs on %s pid=0x%llx err=%d\n",
853
		  opts->dev_name, sbi->one_comp.obj.partition, ret);
854
	exofs_free_sbi(sbi);
855
	return ret;
856
857
858
859
860
}

/*
 * Set up the superblock (calls exofs_fill_super eventually)
 */
Al Viro's avatar
Al Viro committed
861
static struct dentry *exofs_mount(struct file_system_type *type,
862
			  int flags, const char *dev_name,
Al Viro's avatar
Al Viro committed
863
			  void *data)
864
865
866
867
868
869
{
	struct exofs_mountopt opts;
	int ret;

	ret = parse_options(data, &opts);
	if (ret)
Al Viro's avatar
Al Viro committed
870
		return ERR_PTR(ret);
871

872
873
	if (!opts.dev_name)
		opts.dev_name = dev_name;
Al Viro's avatar
Al Viro committed
874
	return mount_nodev(type, flags, &opts, exofs_fill_super);
875
876
877
878
879
880
881
882
883
884
}

/*
 * Return information about the file system state in the buffer.  This is used
 * by the 'df' command, for example.
 */
static int exofs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct exofs_sb_info *sbi = sb->s_fs_info;
885
	struct ore_io_state *ios;
886
887
888
889
890
891
892
893
894
895
	struct osd_attr attrs[] = {
		ATTR_DEF(OSD_APAGE_PARTITION_QUOTAS,
			OSD_ATTR_PQ_CAPACITY_QUOTA, sizeof(__be64)),
		ATTR_DEF(OSD_APAGE_PARTITION_INFORMATION,
			OSD_ATTR_PI_USED_CAPACITY, sizeof(__be64)),
	};
	uint64_t capacity = ULLONG_MAX;
	uint64_t used = ULLONG_MAX;
	int ret;

896
	ret = ore_get_io_state(&sbi->layout, &sbi->oc, &ios);
897
	if (ret) {
898
		EXOFS_DBGMSG("ore_get_io_state failed.\n");
899
		return ret;
900
901
	}

902
903
904
	ios->in_attr = attrs;
	ios->in_attr_len = ARRAY_SIZE(attrs);

905
	ret = ore_read(ios);
906
907
908
	if (unlikely(ret))
		goto out;

909
	ret = extract_attr_from_ios(ios, &attrs[0]);
910
	if (likely(!ret)) {
911
		capacity = get_unaligned_be64(attrs[0].val_ptr);
912
913
914
		if (unlikely(!capacity))
			capacity = ULLONG_MAX;
	} else
915
916
		EXOFS_DBGMSG("exofs_statfs: get capacity failed.\n");

917
	ret = extract_attr_from_ios(ios, &attrs[1]);
918
919
920
921
922
923
924
925
	if (likely(!ret))
		used = get_unaligned_be64(attrs[1].val_ptr);
	else
		EXOFS_DBGMSG("exofs_statfs: get used-space failed.\n");

	/* fill in the stats buffer */
	buf->f_type = EXOFS_SUPER_MAGIC;
	buf->f_bsize = EXOFS_BLKSIZE;
926
927
	buf->f_blocks = capacity >> 9;
	buf->f_bfree = (capacity - used) >> 9;
928
929
930
931
932
933
	buf->f_bavail = buf->f_bfree;
	buf->f_files = sbi->s_numfiles;
	buf->f_ffree = EXOFS_MAX_ID - sbi->s_numfiles;
	buf->f_namelen = EXOFS_NAME_LEN;

out:
934
	ore_put_io_state(ios);
935
936
937
938
939
940
941
	return ret;
}

static const struct super_operations exofs_sops = {
	.alloc_inode    = exofs_alloc_inode,
	.destroy_inode  = exofs_destroy_inode,
	.write_inode    = exofs_write_inode,
Al Viro's avatar
Al Viro committed
942
	.evict_inode    = exofs_evict_inode,
943
	.put_super      = exofs_put_super,
Christoph Hellwig's avatar
Christoph Hellwig committed
944
	.sync_fs	= exofs_sync_fs,
945
946
947
	.statfs         = exofs_statfs,
};

Boaz Harrosh's avatar
Boaz Harrosh committed
948
949
950
951
/******************************************************************************
 * EXPORT OPERATIONS
 *****************************************************************************/

952
static struct dentry *exofs_get_parent(struct dentry *child)
Boaz Harrosh's avatar
Boaz Harrosh committed
953
954
955
956
{
	unsigned long ino = exofs_parent_ino(child);

	if (!ino)
Al Viro's avatar
Al Viro committed
957
		return ERR_PTR(-ESTALE);
Boaz Harrosh's avatar
Boaz Harrosh committed
958

959
	return d_obtain_alias(exofs_iget(child->d_sb, ino));
Boaz Harrosh's avatar
Boaz Harrosh committed
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
}

static struct inode *exofs_nfs_get_inode(struct super_block *sb,
		u64 ino, u32 generation)
{
	struct inode *inode;

	inode = exofs_iget(sb, ino);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (generation && inode->i_generation != generation) {
		/* we didn't find the right inode.. */
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return inode;
}

static struct dentry *exofs_fh_to_dentry(struct super_block *sb,
				struct fid *fid, int fh_len, int fh_type)
{
	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
				    exofs_nfs_get_inode);
}

static struct dentry *exofs_fh_to_parent(struct super_block *sb,
				struct fid *fid, int fh_len, int fh_type)
{
	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
				    exofs_nfs_get_inode);
}

static const struct export_operations exofs_export_ops = {
	.fh_to_dentry = exofs_fh_to_dentry,
	.fh_to_parent = exofs_fh_to_parent,
	.get_parent = exofs_get_parent,
};

998
999
1000
1001
1002
1003
1004
1005
1006
1007
/******************************************************************************
 * INSMOD/RMMOD
 *****************************************************************************/

/*
 * struct that describes this file system
 */
static struct file_system_type exofs_type = {
	.owner          = THIS_MODULE,
	.name           = "exofs",
Al Viro's avatar
Al Viro committed
1008
	.mount          = exofs_mount,
1009
1010
	.kill_sb        = generic_shutdown_super,
};
1011
MODULE_ALIAS_FS("exofs");
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024

static int __init init_exofs(void)
{
	int err;

	err = init_inodecache();
	if (err)
		goto out;

	err = register_filesystem(&exofs_type);
	if (err)
		goto out_d;

1025
1026
1027
	/* We don't fail if sysfs creation failed */
	exofs_sysfs_init();

1028
1029
1030
1031
1032
1033
1034
1035
1036
	return 0;
out_d:
	destroy_inodecache();
out:
	return err;
}

static void __exit exit_exofs(void)
{
1037
	exofs_sysfs_uninit();
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
	unregister_filesystem(&exofs_type);
	destroy_inodecache();
}

MODULE_AUTHOR("Avishay Traeger <avishay@gmail.com>");
MODULE_DESCRIPTION("exofs");
MODULE_LICENSE("GPL");

module_init(init_exofs)
module_exit(exit_exofs)