kern/src/blockdev.c

   1 /* Copyright (c) 2010 The Regents of the University of California
   2  * Barret Rhoden <brho@cs.berkeley.edu>
   3  * See LICENSE for details.
   4  *
   5  * Block devices and generic blockdev infrastructure */
   6
   7 #include <devfs.h>
   8 #include <blockdev.h>
   9 #include <kmalloc.h>
  10 #include <slab.h>
  11 #include <page_alloc.h>
  12 #include <pmap.h>
  13 /* These two are needed for the fake interrupt */
  14 #include <alarm.h>
  15 #include <smp.h>
  16
  17 struct file_operations block_f_op;
  18 struct page_map_operations block_pm_op;
  19 struct kmem_cache *breq_kcache;
  20
  21 void block_init(void)
  22 {
  23         breq_kcache = kmem_cache_create("block_reqs",
  24                                         sizeof(struct block_request),
  25                                         __alignof__(struct block_request), 0,
  26                                         NULL, 0, 0, NULL);
  27         bh_kcache = kmem_cache_create("buffer_heads",
  28                                       sizeof(struct buffer_head),
  29                                       __alignof__(struct buffer_head), 0,
  30                                       NULL, 0, 0, NULL);
  31
  32         #ifdef CONFIG_EXT2FS
  33         /* Now probe for and init the block device for the ext2 ram disk */
  34         extern uint8_t _binary_mnt_ext2fs_img_size[];
  35         extern uint8_t _binary_mnt_ext2fs_img_start[];
  36         /* Build and init the block device */
  37         struct block_device *ram_bd = kmalloc(sizeof(struct block_device), 0);
  38         memset(ram_bd, 0, sizeof(struct block_device));
  39         ram_bd->b_id = 31337;
  40         ram_bd->b_sector_sz = 512;
  41         ram_bd->b_nr_sector = (unsigned long)_binary_mnt_ext2fs_img_size / 512;
  42         kref_init(&ram_bd->b_kref, fake_release, 1);
  43         pm_init(&ram_bd->b_pm, &block_pm_op, ram_bd);
  44         ram_bd->b_data = _binary_mnt_ext2fs_img_start;
  45         strlcpy(ram_bd->b_name, "RAMDISK", BDEV_INLINE_NAME);
  46         /* Connect it to the file system */
  47         struct file *ram_bf = make_device("/dev_vfs/ramdisk", S_IRUSR | S_IWUSR,
  48                                           __S_IFBLK, &block_f_op);
  49         /* make sure the inode tracks the right pm (not it's internal one) */
  50         ram_bf->f_dentry->d_inode->i_mapping = &ram_bd->b_pm;
  51         ram_bf->f_dentry->d_inode->i_bdev = ram_bd;     /* this holds the bd kref */
  52         kref_put(&ram_bf->f_kref);
  53         #endif /* CONFIG_EXT2FS */
  54 }
  55
  56 /* Generic helper, returns a kref'd reference out of principle. */
  57 struct block_device *get_bdev(char *path)
  58 {
  59         struct block_device *bdev;
  60         struct file *block_f;
  61         block_f = do_file_open(path, O_RDWR, 0);
  62         assert(block_f);
  63         bdev = block_f->f_dentry->d_inode->i_bdev;
  64         kref_get(&bdev->b_kref, 1);
  65         kref_put(&block_f->f_kref);
  66         return bdev;
  67 }
  68
  69 /* Frees all the BHs associated with page.  There could be 0, to deal with one
  70  * that wasn't UPTODATE.  Don't call this on a page that isn't a PG_BUFFER.
  71  * Note, these are not a circular LL (for now). */
  72 void free_bhs(struct page *page)
  73 {
  74         struct buffer_head *bh, *next;
  75         assert(atomic_read(&page->pg_flags) & PG_BUFFER);
  76         bh = (struct buffer_head*)page->pg_private;
  77         while (bh) {
  78                 next = bh->bh_next;
  79                 bh->bh_next = 0;
  80                 kmem_cache_free(bh_kcache, bh);
  81                 bh = next;
  82         }
  83         page->pg_private = 0;           /* catch bugs */
  84 }
  85
  86 /* This ultimately will handle the actual request processing, all the way down
  87  * to the driver, and will deal with blocking.  For now, we just fulfill the
  88  * request right away (RAM based block devs). */
  89 int bdev_submit_request(struct block_device *bdev, struct block_request *breq)
  90 {
  91         void *src, *dst;
  92         unsigned long first_sector;
  93         unsigned int nr_sector;
  94
  95         for (int i = 0; i < breq->nr_bhs; i++) {
  96                 first_sector = breq->bhs[i]->bh_sector;
  97                 nr_sector = breq->bhs[i]->bh_nr_sector;
  98                 /* Sectors are indexed starting with 0, for now. */
  99                 if (first_sector + nr_sector > bdev->b_nr_sector) {
 100                         warn("Exceeding the num sectors!");
 101                         return -1;
 102                 }
 103                 if (breq->flags & BREQ_READ) {
 104                         dst = breq->bhs[i]->bh_buffer;
 105                         src = bdev->b_data + (first_sector << SECTOR_SZ_LOG);
 106                 } else if (breq->flags & BREQ_WRITE) {
 107                         dst = bdev->b_data + (first_sector << SECTOR_SZ_LOG);
 108                         src = breq->bhs[i]->bh_buffer;
 109                 } else {
 110                         panic("Need a request type!\n");
 111                 }
 112                 memcpy(dst, src, nr_sector << SECTOR_SZ_LOG);
 113         }
 114         /* Faking the device interrupt with an alarm */
 115         void breq_handler(struct alarm_waiter *waiter)
 116         {
 117                 /* In the future, we'll need to figure out which breq this was in
 118                  * response to */
 119                 struct block_request *breq = (struct block_request*)waiter->data;
 120                 if (breq->callback)
 121                         breq->callback(breq);
 122                 kfree(waiter);
 123         }
 124         struct timer_chain *tchain = &per_cpu_info[core_id()].tchain;
 125         struct alarm_waiter *waiter = kmalloc(sizeof(struct alarm_waiter), 0);
 126         init_awaiter(waiter, breq_handler);
 127         /* Stitch things up, so we know how to find things later */
 128         waiter->data = breq;
 129         /* Set for 5ms. */
 130         set_awaiter_rel(waiter, 5000);
 131         set_alarm(tchain, waiter);
 132         return 0;
 133 }
 134
 135 /* Helper method, unblocks someone blocked on sleep_on_breq(). */
 136 void generic_breq_done(struct block_request *breq)
 137 {
 138         int8_t irq_state = 0;
 139         if (!sem_up_irqsave(&breq->sem, &irq_state)) {
 140                 /* This shouldn't happen anymore.  Let brho know if it does. */
 141                 warn("[kernel] no one waiting on breq %p", breq);
 142         }
 143 }
 144
 145 /* Helper, pairs with generic_breq_done().  Note we sleep here on a semaphore
 146  * instead of faking it with an alarm.  Ideally, this code will be the same even
 147  * for real block devices (that don't fake things with timer interrupts). */
 148 void sleep_on_breq(struct block_request *breq)
 149 {
 150         int8_t irq_state = 0;
 151         /* Since printk takes a while, this may make you lose the race */
 152         printd("Sleeping on breq %p\n", breq);
 153         assert(irq_is_enabled());
 154         sem_down_irqsave(&breq->sem, &irq_state);
 155 }
 156
 157 /* This just tells the page cache that it is 'up to date'.  Due to the nature of
 158  * the blocks in the page cache, we don't actually read the items in on
 159  * readpage, we read them in when a specific block is there */
 160 int block_readpage(struct page_map *pm, struct page *page)
 161 {
 162         atomic_or(&page->pg_flags, PG_UPTODATE);
 163         return 0;
 164 }
 165
 166 /* Returns a BH pointing to the buffer where blk_num from bdev is located (given
 167  * blocks of size blk_sz).  This uses the page cache for the page allocations
 168  * and evictions, but only caches blocks that are requested.  Check the docs for
 169  * more info.  The BH isn't refcounted, but a page refcnt is returned.  Call
 170  * put_block (nand/xor dirty block).
 171  *
 172  * Note we're using the lock_page() to sync (which is what we do with the page
 173  * cache too.  It's not ideal, but keeps things simpler for now.
 174  *
 175  * Also note we're a little inconsistent with the use of sector sizes in certain
 176  * files.  We'll sort it eventually. */
 177 struct buffer_head *bdev_get_buffer(struct block_device *bdev,
 178                                     unsigned long blk_num, unsigned int blk_sz)
 179 {
 180         struct page *page;
 181         struct page_map *pm = &bdev->b_pm;
 182         struct buffer_head *bh, *new, *prev, **next_loc;
 183         struct block_request *breq;
 184         int error;
 185         unsigned int blk_per_pg = PGSIZE / blk_sz;
 186         unsigned int sct_per_blk = blk_sz / bdev->b_sector_sz;
 187         unsigned int blk_offset = (blk_num % blk_per_pg) * blk_sz;
 188         void *my_buf;
 189         assert(blk_offset < PGSIZE);
 190         if (!blk_num)
 191                 warn("Asking for the 0th block of a bdev...");
 192         /* Make sure there's a page in the page cache.  Should always be one. */
 193         error = pm_load_page(pm, blk_num / blk_per_pg, &page);
 194         if (error)
 195                 panic("Failed to load page! (%d)", error);
 196         my_buf = page2kva(page) + blk_offset;
 197         atomic_or(&page->pg_flags, PG_BUFFER);
 198 retry:
 199         bh = (struct buffer_head*)page->pg_private;
 200         prev = 0;
 201         /* look through all the BHs for ours, stopping if we go too far. */
 202         while (bh) {
 203                 if (bh->bh_buffer == my_buf) {
 204                         goto found;
 205                 } else if (bh->bh_buffer > my_buf) {
 206                         break;
 207                 }
 208                 prev = bh;
 209                 bh = bh->bh_next;
 210         }
 211         /* At this point, bh points to the one beyond our space (or 0), and prev is
 212          * either the one before us or 0.  We make a BH, and try to insert */
 213         new = kmem_cache_alloc(bh_kcache, 0);
 214         assert(new);
 215         new->bh_page = page;                                    /* weak ref */
 216         new->bh_buffer = my_buf;
 217         new->bh_flags = 0;
 218         new->bh_next = bh;
 219         new->bh_bdev = bdev;                                    /* uncounted ref */
 220         new->bh_sector = blk_num * sct_per_blk;
 221         new->bh_nr_sector = sct_per_blk;
 222         /* Try to insert the new one in place.  If it fails, retry the whole "find
 223          * the bh" process.  This should be rare, so no sense optimizing it. */
 224         next_loc = prev ? &prev->bh_next : (struct buffer_head**)&page->pg_private;
 225         /* Normally, there'd be an ABA problem here, but we never actually remove
 226          * bhs from the chain until the whole page gets cleaned up, which can't
 227          * happen while we hold a reference to the page. */
 228         if (!atomic_cas_ptr((void**)next_loc, bh, new)) {
 229                 kmem_cache_free(bh_kcache, new);
 230                 goto retry;
 231         }
 232         bh = new;
 233 found:
 234         /* At this point, we have the BH for our buf, but it might not be up to
 235          * date, and there might be someone else trying to update it. */
 236         /* is it already here and up to date?  if so, we're done */
 237         if (bh->bh_flags & BH_UPTODATE)
 238                 return bh;
 239         /* if not, try to lock the page (could BLOCK).  Using this for syncing. */
 240         lock_page(page);
 241         /* double check, are we up to date?  if so, we're done */
 242         if (bh->bh_flags & BH_UPTODATE) {
 243                 unlock_page(page);
 244                 return bh;
 245         }
 246         /* if we're here, the page is locked by us, we need to read the block */
 247         breq = kmem_cache_alloc(breq_kcache, 0);
 248         assert(breq);
 249         breq->flags = BREQ_READ;
 250         breq->callback = generic_breq_done;
 251         breq->data = 0;
 252         sem_init_irqsave(&breq->sem, 0);
 253         breq->bhs = breq->local_bhs;
 254         breq->bhs[0] = bh;
 255         breq->nr_bhs = 1;
 256         error = bdev_submit_request(bdev, breq);
 257         assert(!error);
 258         sleep_on_breq(breq);
 259         kmem_cache_free(breq_kcache, breq);
 260         /* after the data is read, we mark it up to date and unlock the page. */
 261         bh->bh_flags |= BH_UPTODATE;
 262         unlock_page(page);
 263         return bh;
 264 }
 265
 266 /* Will dirty the block/BH/page for the given block/buffer.  Will have to be
 267  * careful with the page reclaimer - if someone holds a reference, they can
 268  * still dirty it. */
 269 void bdev_dirty_buffer(struct buffer_head *bh)
 270 {
 271         struct page *page = bh->bh_page;
 272         /* TODO: race on flag modification */
 273         bh->bh_flags |= BH_DIRTY;
 274         atomic_or(&page->pg_flags, PG_DIRTY);
 275 }
 276
 277 /* Decrefs the buffer from bdev_get_buffer().  Call this when you no longer
 278  * reference your block/buffer.  For now, we do refcnting on the page, since the
 279  * reclaiming will be in page sized chunks from the page cache. */
 280 void bdev_put_buffer(struct buffer_head *bh)
 281 {
 282         pm_put_page(bh->bh_page);
 283 }
 284
 285 /* Block device page map ops: */
 286 struct page_map_operations block_pm_op = {
 287         block_readpage,
 288 };
 289
 290 /* Block device file ops: for now, we don't let you do much of anything */
 291 struct file_operations block_f_op = {
 292         dev_c_llseek,
 293         0,
 294         0,
 295         kfs_readdir,    /* this will fail gracefully */
 296         dev_mmap,
 297         kfs_open,
 298         kfs_flush,
 299         kfs_release,
 300         0,      /* fsync - makes no sense */
 301         kfs_poll,
 302         0,      /* readv */
 303         0,      /* writev */
 304         kfs_sendpage,
 305         kfs_check_flags,
 306 };