cregit-Linux how code gets into the kernel

Release 4.7 fs/block_dev.c

Directory: fs
/*
 *  linux/fs/block_dev.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
 */

#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fcntl.h>
#include <linux/slab.h>
#include <linux/kmod.h>
#include <linux/major.h>
#include <linux/device_cgroup.h>
#include <linux/highmem.h>
#include <linux/blkdev.h>
#include <linux/backing-dev.h>
#include <linux/module.h>
#include <linux/blkpg.h>
#include <linux/magic.h>
#include <linux/buffer_head.h>
#include <linux/swap.h>
#include <linux/pagevec.h>
#include <linux/writeback.h>
#include <linux/mpage.h>
#include <linux/mount.h>
#include <linux/uio.h>
#include <linux/namei.h>
#include <linux/log2.h>
#include <linux/cleancache.h>
#include <linux/dax.h>
#include <linux/badblocks.h>
#include <asm/uaccess.h>
#include "internal.h"


struct bdev_inode {
	
struct block_device bdev;
	
struct inode vfs_inode;
};


static const struct address_space_operations def_blk_aops;


static inline struct bdev_inode *BDEV_I(struct inode *inode) { return container_of(inode, struct bdev_inode, vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton25100.00%1100.00%
Total25100.00%1100.00%


struct block_device *I_BDEV(struct inode *inode) { return &BDEV_I(inode)->bdev; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton21100.00%1100.00%
Total21100.00%1100.00%

EXPORT_SYMBOL(I_BDEV);
void __vfs_msg(struct super_block *sb, const char *prefix, const char *fmt, ...) { struct va_format vaf; va_list args; va_start(args, fmt); vaf.fmt = fmt; vaf.va = &args; printk_ratelimited("%sVFS (%s): %pV\n", prefix, sb->s_id, &vaf); va_end(args); }

Contributors

PersonTokensPropCommitsCommitProp
toshi kanitoshi kani68100.00%1100.00%
Total68100.00%1100.00%


static void bdev_write_inode(struct block_device *bdev) { struct inode *inode = bdev->bd_inode; int ret; spin_lock(&inode->i_lock); while (inode->i_state & I_DIRTY) { spin_unlock(&inode->i_lock); ret = write_inode_now(inode, true); if (ret) { char name[BDEVNAME_SIZE]; pr_warn_ratelimited("VFS: Dirty inode writeback failed " "for block device %s (err=%d).\n", bdevname(bdev, name), ret); } spin_lock(&inode->i_lock); } spin_unlock(&inode->i_lock); }

Contributors

PersonTokensPropCommitsCommitProp
vivek goyalvivek goyal4241.58%116.67%
dave chinnerdave chinner3635.64%233.33%
christoph hellwigchristoph hellwig1716.83%116.67%
jan karajan kara43.96%116.67%
tejun heotejun heo21.98%116.67%
Total101100.00%6100.00%

/* Kill _all_ buffers and pagecache , dirty or not.. */
void kill_bdev(struct block_device *bdev) { struct address_space *mapping = bdev->bd_inode->i_mapping; if (mapping->nrpages == 0 && mapping->nrexceptional == 0) return; invalidate_bh_lrus(); truncate_inode_pages(mapping, 0); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro1532.61%120.00%
linus torvaldslinus torvalds1328.26%120.00%
peter zijlstrapeter zijlstra1226.09%120.00%
johannes weinerjohannes weiner510.87%120.00%
ross zwislerross zwisler12.17%120.00%
Total46100.00%5100.00%

EXPORT_SYMBOL(kill_bdev); /* Invalidate clean unused buffers and pagecache. */
void invalidate_bdev(struct block_device *bdev) { struct address_space *mapping = bdev->bd_inode->i_mapping; if (mapping->nrpages == 0) return; invalidate_bh_lrus(); lru_add_drain_all(); /* make sure all lru add caches are flushed */ invalidate_mapping_pages(mapping, 0, -1); /* 99% of the time, we don't need to flush the cleancache on the bdev. * But, for the strange corners, lets be cautious */ cleancache_invalidate_inode(mapping); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro4279.25%133.33%
linus torvaldslinus torvalds1018.87%133.33%
dan magenheimerdan magenheimer11.89%133.33%
Total53100.00%3100.00%

EXPORT_SYMBOL(invalidate_bdev);
int set_blocksize(struct block_device *bdev, int size) { /* Size must be a power of two, and between 512 and PAGE_SIZE */ if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size)) return -EINVAL; /* Size cannot be smaller than the size supported by the device */ if (size < bdev_logical_block_size(bdev)) return -EINVAL; /* Don't change the size if it is same as current */ if (bdev->bd_block_size != size) { sync_blockdev(bdev); bdev->bd_block_size = size; bdev->bd_inode->i_blkbits = blksize_bits(size); kill_bdev(bdev); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds6573.03%220.00%
al viroal viro1213.48%440.00%
mika kukkonenmika kukkonen66.74%110.00%
vignesh babuvignesh babu44.49%110.00%
martin k. petersenmartin k. petersen11.12%110.00%
andrew mortonandrew morton11.12%110.00%
Total89100.00%10100.00%

EXPORT_SYMBOL(set_blocksize);
int sb_set_blocksize(struct super_block *sb, int size) { if (set_blocksize(sb->s_bdev, size)) return 0; /* If we get here, we know size is power of two * and it's value is between 512 and PAGE_SIZE */ sb->s_blocksize = size; sb->s_blocksize_bits = blksize_bits(size); return sb->s_blocksize; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds4287.50%125.00%
coywolf qi huntcoywolf qi hunt48.33%125.00%
al viroal viro12.08%125.00%
mika kukkonenmika kukkonen12.08%125.00%
Total48100.00%4100.00%

EXPORT_SYMBOL(sb_set_blocksize);
int sb_min_blocksize(struct super_block *sb, int size) { int minsize = bdev_logical_block_size(sb->s_bdev); if (size < minsize) size = minsize; return sb_set_blocksize(sb, size); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds3995.12%133.33%
martin k. petersenmartin k. petersen12.44%133.33%
al viroal viro12.44%133.33%
Total41100.00%3100.00%

EXPORT_SYMBOL(sb_min_blocksize);
static int blkdev_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh, int create) { bh->b_bdev = I_BDEV(inode); bh->b_blocknr = iblock; set_buffer_mapped(bh); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1840.00%222.22%
linus torvaldslinus torvalds1328.89%333.33%
pre-gitpre-git817.78%333.33%
kenneth w. chenkenneth w. chen613.33%111.11%
Total45100.00%9100.00%


static struct inode *bdev_file_inode(struct file *file) { return file->f_mapping->host; }

Contributors

PersonTokensPropCommitsCommitProp
dan williamsdan williams20100.00%1100.00%
Total20100.00%1100.00%


static ssize_t blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter) { struct file *file = iocb->ki_filp; struct inode *inode = bdev_file_inode(file); if (IS_DAX(inode)) return dax_do_io(iocb, inode, iter, blkdev_get_block, NULL, DIO_SKIP_DIO_COUNT); return __blockdev_direct_IO(iocb, inode, I_BDEV(inode), iter, blkdev_get_block, NULL, NULL, DIO_SKIP_DIO_COUNT); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3441.98%743.75%
matthew wilcoxmatthew wilcox2328.40%16.25%
linus torvaldslinus torvalds1012.35%212.50%
christoph hellwigchristoph hellwig44.94%16.25%
al viroal viro33.70%16.25%
dan williamsdan williams33.70%16.25%
chuck leverchuck lever22.47%16.25%
kenneth w. chenkenneth w. chen11.23%16.25%
jens axboejens axboe11.23%16.25%
Total81100.00%16100.00%


int __sync_blockdev(struct block_device *bdev, int wait) { if (!bdev) return 0; if (!wait) return filemap_flush(bdev->bd_inode->i_mapping); return filemap_write_and_wait(bdev->bd_inode->i_mapping); }

Contributors

PersonTokensPropCommitsCommitProp
jan karajan kara2656.52%150.00%
nick pigginnick piggin2043.48%150.00%
Total46100.00%2100.00%

/* * Write out and wait upon all the dirty data associated with a block * device via its mapping. Does not take the superblock lock. */
int sync_blockdev(struct block_device *bdev) { return __sync_blockdev(bdev, 1); }

Contributors

PersonTokensPropCommitsCommitProp
jan karajan kara1583.33%150.00%
nick pigginnick piggin316.67%150.00%
Total18100.00%2100.00%

EXPORT_SYMBOL(sync_blockdev); /* * Write out and wait upon all dirty data associated with this * device. Filesystem data as well as the underlying block * device. Takes the superblock lock. */
int fsync_bdev(struct block_device *bdev) { struct super_block *sb = get_super(bdev); if (sb) { int res = sync_filesystem(sb); drop_super(sb); return res; } return sync_blockdev(bdev); }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin4797.92%150.00%
jan karajan kara12.08%150.00%
Total48100.00%2100.00%

EXPORT_SYMBOL(fsync_bdev); /** * freeze_bdev -- lock a filesystem and force it into a consistent state * @bdev: blockdevice to lock * * If a superblock is found on this device, we take the s_umount semaphore * on it to make sure nobody unmounts until the snapshot creation is done. * The reference counter (bd_fsfreeze_count) guarantees that only the last * unfreeze process can unfreeze the frozen filesystem actually when multiple * freeze requests arrive simultaneously. It counts up in freeze_bdev() and * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze * actually. */
struct super_block *freeze_bdev(struct block_device *bdev) { struct super_block *sb; int error = 0; mutex_lock(&bdev->bd_fsfreeze_mutex); if (++bdev->bd_fsfreeze_count > 1) { /* * We don't even need to grab a reference - the first call * to freeze_bdev grab an active reference and only the last * thaw_bdev drops it. */ sb = get_super(bdev); drop_super(sb); mutex_unlock(&bdev->bd_fsfreeze_mutex); return sb; } sb = get_active_super(bdev); if (!sb) goto out; if (sb->s_op->freeze_super) error = sb->s_op->freeze_super(sb); else error = freeze_super(sb); if (error) { deactivate_super(sb); bdev->bd_fsfreeze_count--; mutex_unlock(&bdev->bd_fsfreeze_mutex); return ERR_PTR(error); } deactivate_super(sb); out: sync_blockdev(bdev); mutex_unlock(&bdev->bd_fsfreeze_mutex); return sb; /* thaw_bdev releases s->s_umount */ }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin11772.67%120.00%
christoph hellwigchristoph hellwig2113.04%240.00%
benjamin marzinskibenjamin marzinski2012.42%120.00%
josef bacikjosef bacik31.86%120.00%
Total161100.00%5100.00%

EXPORT_SYMBOL(freeze_bdev); /** * thaw_bdev -- unlock filesystem * @bdev: blockdevice to unlock * @sb: associated superblock * * Unlocks the filesystem and marks it writeable again after freeze_bdev(). */
int thaw_bdev(struct block_device *bdev, struct super_block *sb) { int error = -EINVAL; mutex_lock(&bdev->bd_fsfreeze_mutex); if (!bdev->bd_fsfreeze_count) goto out; error = 0; if (--bdev->bd_fsfreeze_count > 0) goto out; if (!sb) goto out; if (sb->s_op->thaw_super) error = sb->s_op->thaw_super(sb); else error = thaw_super(sb); if (error) { bdev->bd_fsfreeze_count++; mutex_unlock(&bdev->bd_fsfreeze_mutex); return error; } out: mutex_unlock(&bdev->bd_fsfreeze_mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin8668.80%125.00%
benjamin marzinskibenjamin marzinski2016.00%125.00%
christoph hellwigchristoph hellwig1411.20%125.00%
josef bacikjosef bacik54.00%125.00%
Total125100.00%4100.00%

EXPORT_SYMBOL(thaw_bdev);
static int blkdev_writepage(struct page *page, struct writeback_control *wbc) { return block_write_full_page(page, blkdev_get_block, wbc); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds1973.08%266.67%
andrew mortonandrew morton726.92%133.33%
Total26100.00%3100.00%


static int blkdev_readpage(struct file * file, struct page * page) { return block_read_full_page(page, blkdev_get_block); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2083.33%250.00%
pre-gitpre-git416.67%250.00%
Total24100.00%4100.00%


static int blkdev_readpages(struct file *file, struct address_space *mapping, struct list_head *pages, unsigned nr_pages) { return mpage_readpages(mapping, pages, nr_pages, blkdev_get_block); }

Contributors

PersonTokensPropCommitsCommitProp
akinobu mitaakinobu mita36100.00%1100.00%
Total36100.00%1100.00%


static int blkdev_write_begin(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned flags, struct page **pagep, void **fsdata) { return block_write_begin(mapping, pos, len, flags, pagep, blkdev_get_block); }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin2853.85%116.67%
linus torvaldslinus torvalds2140.38%350.00%
pre-gitpre-git23.85%116.67%
christoph hellwigchristoph hellwig11.92%116.67%
Total52100.00%6100.00%


static int blkdev_write_end(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata) { int ret; ret = block_write_end(file, mapping, pos, len, copied, page, fsdata); unlock_page(page); put_page(page); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin4666.67%125.00%
linus torvaldslinus torvalds2028.99%125.00%
pre-gitpre-git22.90%125.00%
kirill a. shutemovkirill a. shutemov11.45%125.00%
Total69100.00%4100.00%

/* * private llseek: * for a block special file file_inode(file)->i_size is zero * so we compute the size by hand (just as in block_read/write above) */
static loff_t block_llseek(struct file *file, loff_t offset, int whence) { struct inode *bd_inode = bdev_file_inode(file); loff_t retval; inode_lock(bd_inode); retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode)); inode_unlock(bd_inode); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2237.29%440.00%
pre-gitpre-git1932.20%110.00%
al viroal viro1220.34%220.00%
dan williamsdan williams35.08%110.00%
linus torvaldslinus torvalds35.08%220.00%
Total59100.00%10100.00%


int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync) { struct inode *bd_inode = bdev_file_inode(filp); struct block_device *bdev = I_BDEV(bd_inode); int error; error = filemap_write_and_wait_range(filp->f_mapping, start, end); if (error) return error; /* * There is no need to serialise calls to blkdev_issue_flush with * i_mutex and doing so causes performance issues with concurrent * O_SYNC writers to a block device. */ error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL); if (error == -EOPNOTSUPP) error = 0; return error; }

Contributors

PersonTokensPropCommitsCommitProp
christoph hellwigchristoph hellwig2932.95%19.09%
rafael j. wysockirafael j. wysocki2022.73%19.09%
pre-gitpre-git1314.77%327.27%
anton blanchardanton blanchard1213.64%19.09%
josef bacikjosef bacik66.82%19.09%
andrew mortonandrew morton33.41%218.18%
dan williamsdan williams33.41%19.09%
dmitriy monakhovdmitriy monakhov22.27%19.09%
Total88100.00%11100.00%

EXPORT_SYMBOL(blkdev_fsync); /** * bdev_read_page() - Start reading a page from a block device * @bdev: The device to read the page from * @sector: The offset on the device to read the page to (need not be aligned) * @page: The page to read * * On entry, the page should be locked. It will be unlocked when the page * has been read. If the block driver implements rw_page synchronously, * that will be true on exit from this function, but it need not be. * * Errors returned by this function are usually "soft", eg out of memory, or * queue full; callers should try a different route to read this page rather * than propagate an error back up the stack. * * Return: negative errno if an error occurs, 0 if submission was successful. */
int bdev_read_page(struct block_device *bdev, sector_t sector, struct page *page) { const struct block_device_operations *ops = bdev->bd_disk->fops; int result = -EOPNOTSUPP; if (!ops->rw_page || bdev_get_integrity(bdev)) return result; result = blk_queue_enter(bdev->bd_queue, false); if (result) return result; result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, READ); blk_queue_exit(bdev->bd_queue); return result; }

Contributors

PersonTokensPropCommitsCommitProp
matthew wilcoxmatthew wilcox5858.59%125.00%
dan williamsdan williams3535.35%125.00%
vishal vermavishal verma55.05%125.00%
christoph hellwigchristoph hellwig11.01%125.00%
Total99100.00%4100.00%

EXPORT_SYMBOL_GPL(bdev_read_page); /** * bdev_write_page() - Start writing a page to a block device * @bdev: The device to write the page to * @sector: The offset on the device to write the page to (need not be aligned) * @page: The page to write * @wbc: The writeback_control for the write * * On entry, the page should be locked and not currently under writeback. * On exit, if the write started successfully, the page will be unlocked and * under writeback. If the write failed already (eg the driver failed to * queue the page to the device), the page will still be locked. If the * caller is a ->writepage implementation, it will need to unlock the page. * * Errors returned by this function are usually "soft", eg out of memory, or * queue full; callers should try a different route to write this page rather * than propagate an error back up the stack. * * Return: negative errno if an error occurs, 0 if submission was successful. */
int bdev_write_page(struct block_device *bdev, sector_t sector, struct page *page, struct writeback_control *wbc) { int result; int rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE; const struct block_device_operations *ops = bdev->bd_disk->fops; if (!ops->rw_page || bdev_get_integrity(bdev)) return -EOPNOTSUPP; result = blk_queue_enter(bdev->bd_queue, false); if (result) return result; set_page_writeback(page); result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, rw); if (result) end_page_writeback(page); else unlock_page(page); blk_queue_exit(bdev->bd_queue); return result; }

Contributors

PersonTokensPropCommitsCommitProp
matthew wilcoxmatthew wilcox10778.10%125.00%
dan williamsdan williams2417.52%125.00%
vishal vermavishal verma53.65%125.00%
christoph hellwigchristoph hellwig10.73%125.00%
Total137100.00%4100.00%

EXPORT_SYMBOL_GPL(bdev_write_page); /** * bdev_direct_access() - Get the address for directly-accessibly memory * @bdev: The device containing the memory * @dax: control and output parameters for ->direct_access * * If a block device is made up of directly addressable memory, this function * will tell the caller the PFN and the address of the memory. The address * may be directly dereferenced within the kernel without the need to call * ioremap(), kmap() or similar. The PFN is suitable for inserting into * page tables. * * Return: negative errno if an error occurs, otherwise the number of bytes * accessible at this address. */
long bdev_direct_access(struct block_device *bdev, struct blk_dax_ctl *dax) { sector_t sector = dax->sector; long avail, size = dax->size; const struct block_device_operations *ops = bdev->bd_disk->fops; /* * The device driver is allowed to sleep, in order to make the * memory directly accessible. */ might_sleep(); if (size < 0) return size; if (!ops->direct_access) return -EOPNOTSUPP; if ((sector + DIV_ROUND_UP(size, 512)) > part_nr_sects_read(bdev->bd_part)) return -ERANGE; sector += get_start_sect(bdev); if (sector % (PAGE_SIZE / 512)) return -EINVAL; avail = ops->direct_access(bdev, sector, &dax->addr, &dax->pfn, size); if (!avail) return -ERANGE; if (avail > 0 && avail & ~PAGE_MASK) return -ENXIO; return min(avail, size); }

Contributors

PersonTokensPropCommitsCommitProp
matthew wilcoxmatthew wilcox12876.65%240.00%
dan williamsdan williams3923.35%360.00%
Total167100.00%5100.00%

EXPORT_SYMBOL_GPL(bdev_direct_access); /** * bdev_dax_supported() - Check if the device supports dax for filesystem * @sb: The superblock of the device * @blocksize: The block size of the device * * This is a library function for filesystems to check if the block device * can be mounted with dax option. * * Return: negative errno if unsupported, 0 if supported. */
int bdev_dax_supported(struct super_block *sb, int blocksize) { struct blk_dax_ctl dax = { .sector = 0, .size = PAGE_SIZE, }; int err; if (blocksize != PAGE_SIZE) { vfs_msg(sb, KERN_ERR, "error: unsupported blocksize for dax"); return -EINVAL; } err = bdev_direct_access(sb->s_bdev, &dax); if (err < 0) { switch (err) { case -EOPNOTSUPP: vfs_msg(sb, KERN_ERR, "error: device does not support dax"); break; case -EINVAL: vfs_msg(sb, KERN_ERR, "error: unaligned partition for dax"); break; default: vfs_msg(sb, KERN_ERR, "error: dax access failed (%d)", err); } return err; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
toshi kanitoshi kani125100.00%1100.00%
Total125100.00%1100.00%

EXPORT_SYMBOL_GPL(bdev_dax_supported); /** * bdev_dax_capable() - Return if the raw device is capable for dax * @bdev: The device for raw block device access */
bool bdev_dax_capable(struct block_device *bdev) { struct blk_dax_ctl dax = { .size = PAGE_SIZE, }; if (!IS_ENABLED(CONFIG_FS_DAX)) return false; dax.sector = 0; if (bdev_direct_access(bdev, &dax) < 0) return false; dax.sector = bdev->bd_part->nr_sects - (PAGE_SIZE / 512); if (bdev_direct_access(bdev, &dax) < 0) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
toshi kanitoshi kani87100.00%1100.00%
Total87100.00%1100.00%

/* * pseudo-fs */ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock); static struct kmem_cache * bdev_cachep __read_mostly;
static struct inode *bdev_alloc_inode(struct super_block *sb) { struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL); if (!ei) return NULL; return &ei->vfs_inode; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro2871.79%120.00%
pre-gitpre-git410.26%120.00%
andrew mortonandrew morton37.69%120.00%
linus torvaldslinus torvalds37.69%120.00%
christoph lameterchristoph lameter12.56%120.00%
Total39100.00%5100.00%


static void bdev_i_callback(struct rcu_head *head) { struct inode *inode = container_of(head, struct inode, i_rcu); struct bdev_inode *bdi = BDEV_I(inode); kmem_cache_free(bdev_cachep, bdi); }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin2046.51%125.00%
andrew mortonandrew morton1125.58%125.00%
al viroal viro1023.26%125.00%
pre-gitpre-git24.65%125.00%
Total43100.00%4100.00%


static void bdev_destroy_inode(struct inode *inode) { call_rcu(&inode->i_rcu, bdev_i_callback); }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin1990.48%150.00%
al viroal viro29.52%150.00%
Total21100.00%2100.00%


static void init_once(void *foo) { struct bdev_inode *ei = (struct bdev_inode *) foo; struct block_device *bdev = &ei->bdev; memset(bdev, 0, sizeof(*bdev)); mutex_init(&bdev->bd_mutex); INIT_LIST_HEAD(&bdev->bd_inodes); INIT_LIST_HEAD(&bdev->bd_list); #ifdef CONFIG_SYSFS INIT_LIST_HEAD(&bdev->bd_holder_disks); #endif inode_init_once(&ei->vfs_inode); /* Initialize mutex for freeze. */ mutex_init(&bdev->bd_fsfreeze_mutex); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro5757.58%116.67%
pre-gitpre-git1515.15%116.67%
tejun heotejun heo1313.13%116.67%
takashi satotakashi sato99.09%116.67%
christoph lameterchristoph lameter33.03%116.67%
arjan van de venarjan van de ven22.02%116.67%
Total99100.00%6100.00%


static inline void __bd_forget(struct inode *inode) { list_del_init(&inode->i_devices); inode->i_bdev = NULL; inode->i_mapping = &inode->i_data; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro35100.00%1100.00%
Total35100.00%1100.00%


static void bdev_evict_inode(struct inode *inode) { struct block_device *bdev = &BDEV_I(inode)->bdev; struct list_head *p; truncate_inode_pages_final(&inode->i_data); invalidate_inode_buffers(inode); /* is it needed here? */ clear_inode(inode); spin_lock(&bdev_lock); while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) { __bd_forget(list_entry(p, struct inode, i_devices)); } list_del_init(&bdev->bd_list); spin_unlock(&bdev_lock); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro9898.00%250.00%
jan karajan kara11.00%125.00%
johannes weinerjohannes weiner11.00%125.00%
Total100100.00%4100.00%

static const struct super_operations bdev_sops = { .statfs = simple_statfs, .alloc_inode = bdev_alloc_inode, .destroy_inode = bdev_destroy_inode, .drop_inode = generic_delete_inode, .evict_inode = bdev_evict_inode, };
static struct dentry *bd_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data) { struct dentry *dent; dent = mount_pseudo(fs_type, "bdev:", &bdev_sops, NULL, BDEVFS_MAGIC); if (dent) dent->d_sb->s_iflags |= SB_I_CGROUPWB; return dent; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro3150.82%342.86%
shaohua lishaohua li2236.07%114.29%
pre-gitpre-git69.84%114.29%
muthu kumarmuthu kumar11.64%114.29%
linus torvaldslinus torvalds11.64%114.29%
Total61100.00%7100.00%

static struct file_system_type bd_type = { .name = "bdev", .mount = bd_mount, .kill_sb = kill_anon_super, }; struct super_block *blockdev_superblock __read_mostly; EXPORT_SYMBOL_GPL(blockdev_superblock);
void __init bdev_cache_init(void) { int err; static struct vfsmount *bd_mnt; bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode), 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| SLAB_MEM_SPREAD|SLAB_ACCOUNT|SLAB_PANIC), init_once); err = register_filesystem(&bd_type); if (err) panic("Cannot register bdev pseudo-fs"); bd_mnt = kern_mount(&bd_type); if (IS_ERR(bd_mnt)) panic("Cannot create bdev pseudo-fs"); blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */ }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds4044.44%216.67%
pre-gitpre-git2628.89%216.67%
andrew mortonandrew morton910.00%216.67%
cheng renquancheng renquan55.56%18.33%
paul jacksonpaul jackson44.44%216.67%
al viroal viro33.33%18.33%
vladimir davydovvladimir davydov22.22%18.33%
sergey senozhatskysergey senozhatsky11.11%18.33%
Total90100.00%12100.00%

/* * Most likely _very_ bad one - but then it's hardly critical for small * /dev and can be fixed when somebody will need really large one. * Keep in mind that it will be fed through icache hash function too. */
static inline unsigned long hash(dev_t dev) { return MAJOR(dev)+MINOR(dev); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds1150.00%133.33%
al viroal viro836.36%133.33%
pre-gitpre-git313.64%133.33%
Total22100.00%3100.00%


static int bdev_test(struct inode *inode, void *data) { return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro2578.12%150.00%
pre-gitpre-git721.88%150.00%
Total32100.00%2100.00%


static int bdev_set(struct inode *inode, void *data) { BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro2264.71%150.00%
pre-gitpre-git1235.29%150.00%
Total34100.00%2100.00%

static LIST_HEAD(all_bdevs);
struct block_device *bdget(