litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@linux-foundation.org>	2012-06-01 13:12:15 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2012-06-01 13:12:15 -0400
commit	4edebed86690eb8db9af3ab85baf4a34e73266cc (patch)
tree	8ab144b08f490f239fa62be52470860c9311664d /fs/nfs/direct.c
parent	51eab603f5c86dd1eae4c525df3e7f7eeab401d6 (diff)
parent	5e44f8c374dc4f8eadf61cd18b2c0d46bc87c1b7 (diff)

Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

Pull Ext4 updates from Theodore Ts'o: "The major new feature added in this update is Darrick J Wong's metadata checksum feature, which adds crc32 checksums to ext4's metadata fields. There is also the usual set of cleanups and bug fixes." * tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (44 commits) ext4: hole-punch use truncate_pagecache_range jbd2: use kmem_cache_zalloc wrapper instead of flag ext4: remove mb_groups before tearing down the buddy_cache ext4: add ext4_mb_unload_buddy in the error path ext4: don't trash state flags in EXT4_IOC_SETFLAGS ext4: let getattr report the right blocks in delalloc+bigalloc ext4: add missing save_error_info() to ext4_error() ext4: add debugging trigger for ext4_error() ext4: protect group inode free counting with group lock ext4: use consistent ssize_t type in ext4_file_write() ext4: fix format flag in ext4_ext_binsearch_idx() ext4: cleanup in ext4_discard_allocated_blocks() ext4: return ENOMEM when mounts fail due to lack of memory ext4: remove redundundant "(char *) bh->b_data" casts ext4: disallow hard-linked directory in ext4_lookup ext4: fix potential integer overflow in alloc_flex_gd() ext4: remove needs_recovery in ext4_mb_init() ext4: force ro mount if ext4_setup_super() fails ext4: fix potential NULL dereference in ext4_free_inodes_counts() ext4/jbd2: add metadata checksumming to the list of supported features ...

Diffstat (limited to 'fs/nfs/direct.c')

0 files changed, 0 insertions, 0 deletions

/* linear.c : Multiple Devices driver for Linux Copyright (C) 1994-96 Marc ZYNGIER <zyngier@ufr-info-p7.ibp.fr> or <maz@gloups.fdn.fr> Linear mode management functions. This program 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; either version 2, or (at your option) any later version. You should have received a copy of the GNU General Public License (for example /usr/src/linux/COPYING); if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <linux/blkdev.h> #include <linux/raid/md_u.h> #include <linux/seq_file.h> #include <linux/module.h> #include <linux/slab.h> #include "md.h" #include "linear.h" /* * find which device holds a particular offset */ static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector) { int lo, mid, hi; struct linear_conf *conf; lo = 0; hi = mddev->raid_disks - 1; conf = mddev->private; /* * Binary Search */ while (hi > lo) { mid = (hi + lo) / 2; if (sector < conf->disks[mid].end_sector) hi = mid; else lo = mid + 1; } return conf->disks + lo; } /* * In linear_congested() conf->raid_disks is used as a copy of * mddev->raid_disks to iterate conf->disks[], because conf->raid_disks * and conf->disks[] are created in linear_conf(), they are always * consitent with each other, but mddev->raid_disks does not. */ static int linear_congested(struct mddev *mddev, int bits) { struct linear_conf *conf; int i, ret = 0; rcu_read_lock(); conf = rcu_dereference(mddev->private); for (i = 0; i < conf->raid_disks && !ret ; i++) { struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev); ret |= bdi_congested(&q->backing_dev_info, bits); } rcu_read_unlock(); return ret; } static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks) { struct linear_conf *conf; sector_t array_sectors; conf = mddev->private; WARN_ONCE(sectors || raid_disks, "%s does not support generic reshape\n", __func__); array_sectors = conf->array_sectors; return array_sectors; } static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) { struct linear_conf *conf; struct md_rdev *rdev; int i, cnt; bool discard_supported = false; conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(struct dev_info), GFP_KERNEL); if (!conf) return NULL; cnt = 0; conf->array_sectors = 0; rdev_for_each(rdev, mddev) { int j = rdev->raid_disk; struct dev_info *disk = conf->disks + j; sector_t sectors; if (j < 0 || j >= raid_disks || disk->rdev) { printk(KERN_ERR "md/linear:%s: disk numbering problem. Aborting!\n", mdname(mddev)); goto out; } disk->rdev = rdev; if (mddev->chunk_sectors) { sectors = rdev->sectors; sector_div(sectors, mddev->chunk_sectors); rdev->sectors = sectors * mddev->chunk_sectors; } disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); conf->array_sectors += rdev->sectors; cnt++; if (blk_queue_discard(bdev_get_queue(rdev->bdev))) discard_supported = true; } if (cnt != raid_disks) { printk(KERN_ERR "md/linear:%s: not enough drives present. Aborting!\n", mdname(mddev)); goto out; } if (!discard_supported) queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, mddev->queue); else queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue); /* * Here we calculate the device offsets. */ conf->disks[0].end_sector = conf->disks[0].rdev->sectors; for (i = 1; i < raid_disks; i++) conf->disks[i].end_sector = conf->disks[i-1].end_sector + conf->disks[i].rdev->sectors; /* * conf->raid_disks is copy of mddev->raid_disks. The reason to * keep a copy of mddev->raid_disks in struct linear_conf is, * mddev->raid_disks may not be consistent with pointers number of * conf->disks[] when it is updated in linear_add() and used to * iterate old conf->disks[] earray in linear_congested(). * Here conf->raid_disks is always consitent with number of * pointers in conf->disks[] array, and mddev->private is updated * with rcu_assign_pointer() in linear_addr(), such race can be * avoided. */ conf->raid_disks = raid_disks; return conf; out: kfree(conf); return NULL; } static int linear_run (struct mddev *mddev) { struct linear_conf *conf; int ret; if (md_check_no_bitmap(mddev)) return -EINVAL; conf = linear_conf(mddev, mddev->raid_disks); if (!conf) return 1; mddev->private = conf; md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); ret = md_integrity_register(mddev); if (ret) { kfree(conf); mddev->private = NULL; } return ret; } static int linear_add(struct mddev *mddev, struct md_rdev *rdev) { /* Adding a drive to a linear array allows the array to grow. * It is permitted if the new drive has a matching superblock * already on it, with raid_disk equal to raid_disks. * It is achieved by creating a new linear_private_data structure * and swapping it in in-place of the current one. * The current one is never freed until the array is stopped. * This avoids races. */ struct linear_conf *newconf, *oldconf; if (rdev->saved_raid_disk != mddev->raid_disks) return -EINVAL; rdev->raid_disk = rdev->saved_raid_disk; rdev->saved_raid_disk = -1; newconf = linear_conf(mddev,mddev->raid_disks+1); if (!newconf) return -ENOMEM; /* newconf->raid_disks already keeps a copy of * the increased * value of mddev->raid_disks, WARN_ONCE() is just used to make * sure of this. It is possible that oldconf is still referenced * in linear_congested(), therefore kfree_rcu() is used to free * oldconf until no one uses it anymore. */ mddev_suspend(mddev); oldconf = rcu_dereference(mddev->private); mddev->raid_disks++; WARN_ONCE(mddev->raid_disks != newconf->raid_disks, "copied raid_disks doesn't match mddev->raid_disks"); rcu_assign_pointer(mddev->private, newconf); md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); set_capacity(mddev->gendisk, mddev->array_sectors); mddev_resume(mddev); revalidate_disk(mddev->gendisk); kfree_rcu(oldconf, rcu); return 0; } static void linear_free(struct mddev *mddev, void *priv) { struct linear_conf *conf = priv; kfree(conf); } static void linear_make_request(struct mddev *mddev, struct bio *bio) { char b[BDEVNAME_SIZE]; struct dev_info *tmp_dev; struct bio *split; sector_t start_sector, end_sector, data_offset;


context:
space:
mode: