/* * Handle actual transfers of data. */ static int sbullr_transfer (Sbull_Dev *dev, char *buf, size_t count, loff_t *offset, int rw) { struct kiobuf *iobuf; int result; /* Only block alignment and size allowed */ if ((*offset & SBULLR_SECTOR_MASK) || (count & SBULLR_SECTOR_MASK)) return -EINVAL; if ((unsigned long) buf & SBULLR_SECTOR_MASK) return -EINVAL; /* Allocate an I/O vector */ result = alloc_kiovec(1, &iobuf); if (result) return result; /* Map the user I/O buffer and do the I/O. */ result = map_user_kiobuf(rw, iobuf, (unsigned long) buf, count); if (result) { free_kiovec(1, &iobuf); return result; } spin_lock(&dev->lock); result = sbullr_rw_iovec(dev, iobuf, rw, *offset >> SBULLR_SECTOR_SHIFT, count >> SBULLR_SECTOR_SHIFT); spin_unlock(&dev->lock); /* Clean up and return. */ unmap_kiobuf(iobuf); free_kiovec(1, &iobuf); if (result > 0) *offset += result << SBULLR_SECTOR_SHIFT; return result << SBULLR_SECTOR_SHIFT; }
static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags, struct file *f) { struct inode *inode; static LIST_HEAD(kill_list); int error; f->f_flags = flags; f->f_mode = (flags+1) & O_ACCMODE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_reada = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); /* preallocate kiobuf for O_DIRECT */ f->f_iobuf = NULL; f->f_iobuf_lock = 0; if (f->f_flags & O_DIRECT) { error = alloc_kiovec(1, &f->f_iobuf); if (error) goto cleanup_all; } if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); /* NB: we're sure to have correct a_ops only after f_op->open */ if (f->f_flags & O_DIRECT) { if (!inode->i_mapping || !inode->i_mapping->a_ops || !(inode->i_mapping->a_ops->direct_IO || inode->i_mapping->a_ops->direct_sector_IO)) { fput(f); f = ERR_PTR(-EINVAL); } } return f; cleanup_all: if (f->f_iobuf) free_kiovec(1, &f->f_iobuf); fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); file_move(f, &kill_list); /* out of the way.. */ f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); dput(dentry); mntput(mnt); return ERR_PTR(error); }
/* This is the kernel thread that empties the write queue to disk */ static int write_queue_task(void *data) { int err; struct task_struct *tsk = current; struct kiobuf *iobuf; DECLARE_WAITQUEUE(wait, tsk); DEBUG(1, "blkmtd: writetask: starting (pid = %d)\n", tsk->pid); daemonize(); strcpy(tsk->comm, "blkmtdd"); tsk->tty = NULL; spin_lock_irq(&tsk->sigmask_lock); sigfillset(&tsk->blocked); recalc_sigpending(tsk); spin_unlock_irq(&tsk->sigmask_lock); exit_sighand(tsk); if(alloc_kiovec(1, &iobuf)) return 0; DEBUG(2, "blkmtd: writetask: entering main loop\n"); add_wait_queue(&thr_wq, &wait); while(1) { spin_lock(&mbd_writeq_lock); if(!write_queue_cnt) { /* If nothing in the queue, wake up anyone wanting to know when there is space in the queue then sleep for 2*HZ */ spin_unlock(&mbd_writeq_lock); DEBUG(3, "blkmtd: writetask: queue empty\n"); if(waitqueue_active(&mtbd_sync_wq)) wake_up(&mtbd_sync_wq); interruptible_sleep_on_timeout(&thr_wq, 2*HZ); DEBUG(3, "blkmtd: writetask: woken up\n"); if(write_task_finish) break; } else { /* we have stuff to write */ mtdblkdev_write_queue_t *item = &write_queue[write_queue_tail]; struct page **pages = item->pages; int pagecnt = item->pagecnt; int pagenr = item->pagenr; int i; int max_sectors = KIO_MAX_SECTORS >> (item->rawdevice->sector_bits - 9); kdev_t dev = to_kdev_t(item->rawdevice->binding->bd_dev); DEBUG(3, "blkmtd: writetask: got %d queue items\n", write_queue_cnt); set_current_state(TASK_RUNNING); spin_unlock(&mbd_writeq_lock); DEBUG(2, "blkmtd: write_task: writing pagenr = %d pagecnt = %d", item->pagenr, item->pagecnt); iobuf->offset = 0; iobuf->locked = 1; /* Loop through all the pages to be written in the queue item, remembering we can only write KIO_MAX_SECTORS at a time */ while(pagecnt) { int sectornr = pagenr << (PAGE_SHIFT - item->rawdevice->sector_bits); int sectorcnt = pagecnt << (PAGE_SHIFT - item->rawdevice->sector_bits); int cursectors = (sectorcnt < max_sectors) ? sectorcnt : max_sectors; int cpagecnt = (cursectors << item->rawdevice->sector_bits) + PAGE_SIZE-1; cpagecnt >>= PAGE_SHIFT; for(i = 0; i < cpagecnt; i++) iobuf->maplist[i] = *(pages++); for(i = 0; i < cursectors; i++) { iobuf->blocks[i] = sectornr++; } iobuf->nr_pages = cpagecnt; iobuf->length = cursectors << item->rawdevice->sector_bits; DEBUG(3, "blkmtd: write_task: about to kiovec\n"); err = brw_kiovec(WRITE, 1, &iobuf, dev, iobuf->blocks, item->rawdevice->sector_size); DEBUG(3, "bklmtd: write_task: done, err = %d\n", err); if(err != (cursectors << item->rawdevice->sector_bits)) { /* if an error occured - set this to exit the loop */ pagecnt = 0; } else { pagenr += cpagecnt; pagecnt -= cpagecnt; } } /* free up the pages used in the write and list of pages used in the write queue item */ iobuf->locked = 0; spin_lock(&mbd_writeq_lock); write_queue_cnt--; write_queue_tail++; write_queue_tail %= WRITE_QUEUE_SZ; for(i = 0 ; i < item->pagecnt; i++) { UnlockPage(item->pages[i]); __free_pages(item->pages[i], 0); } kfree(item->pages); item->pages = NULL; spin_unlock(&mbd_writeq_lock); /* Tell others there is some space in the write queue */ if(waitqueue_active(&mtbd_sync_wq)) wake_up(&mtbd_sync_wq); } } remove_wait_queue(&thr_wq, &wait); DEBUG(1, "blkmtd: writetask: exiting\n"); free_kiovec(1, &iobuf); /* Tell people we have exitd */ up(&thread_sem); return 0; }
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { struct file * f; struct inode *inode; static LIST_HEAD(kill_list); int error; error = -ENFILE; f = get_empty_filp(); if (!f) goto cleanup_dentry; f->f_flags = flags; f->f_mode = (flags+1) & O_ACCMODE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_reada = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); /* preallocate kiobuf for O_DIRECT */ f->f_iobuf = NULL; f->f_iobuf_lock = 0; if (f->f_flags & O_DIRECT) { error = alloc_kiovec(1, &f->f_iobuf); if (error) goto cleanup_all; } if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); return f; cleanup_all: if (f->f_iobuf) free_kiovec(1, &f->f_iobuf); fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); file_move(f, &kill_list); /* out of the way.. */ f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); cleanup_dentry: dput(dentry); mntput(mnt); return ERR_PTR(error); }
/* readpage() - reads one page from the block device */ static int blkmtd_readpage(struct file *file, struct page *page) { int err; int sectornr, sectors, i; struct kiobuf *iobuf; mtd_raw_dev_data_t *rawdevice = (mtd_raw_dev_data_t *)file->private_data; kdev_t dev; if(!rawdevice) { printk("blkmtd: readpage: PANIC file->private_data == NULL\n"); return -EIO; } dev = to_kdev_t(rawdevice->binding->bd_dev); DEBUG(2, "blkmtd: readpage called, dev = `%s' page = %p index = %ld\n", bdevname(dev), page, page->index); if(Page_Uptodate(page)) { DEBUG(1, "blkmtd: readpage page %ld is already upto date\n", page->index); UnlockPage(page); return 0; } ClearPageUptodate(page); ClearPageError(page); /* see if page is in the outgoing write queue */ spin_lock(&mbd_writeq_lock); if(write_queue_cnt) { int i = write_queue_tail; while(i != write_queue_head) { mtdblkdev_write_queue_t *item = &write_queue[i]; if(page->index >= item->pagenr && page->index < item->pagenr+item->pagecnt) { /* yes it is */ int index = item->pagenr - page->index; DEBUG(1, "blkmtd: readpage: found page %ld in outgoing write queue\n", page->index); if(item->iserase) { memset(page_address(page), 0xff, PAGE_SIZE); } else { memcpy(page_address(page), page_address(item->pages[index]), PAGE_SIZE); } SetPageUptodate(page); flush_dcache_page(page); UnlockPage(page); spin_unlock(&mbd_writeq_lock); return 0; } i++; i %= WRITE_QUEUE_SZ; } } spin_unlock(&mbd_writeq_lock); DEBUG(3, "blkmtd: readpage: getting kiovec\n"); err = alloc_kiovec(1, &iobuf); if (err) { return err; } iobuf->offset = 0; iobuf->nr_pages = 1; iobuf->length = PAGE_SIZE; iobuf->locked = 1; iobuf->maplist[0] = page; sectornr = page->index << (PAGE_SHIFT - rawdevice->sector_bits); sectors = 1 << (PAGE_SHIFT - rawdevice->sector_bits); DEBUG(3, "blkmtd: readpage: sectornr = %d sectors = %d\n", sectornr, sectors); for(i = 0; i < sectors; i++) { iobuf->blocks[i] = sectornr++; } DEBUG(3, "bklmtd: readpage: starting brw_kiovec\n"); err = brw_kiovec(READ, 1, &iobuf, dev, iobuf->blocks, rawdevice->sector_size); DEBUG(3, "blkmtd: readpage: finished, err = %d\n", err); iobuf->locked = 0; free_kiovec(1, &iobuf); if(err != PAGE_SIZE) { printk("blkmtd: readpage: error reading page %ld\n", page->index); memset(page_address(page), 0, PAGE_SIZE); SetPageError(page); err = -EIO; } else { DEBUG(3, "blkmtd: readpage: setting page upto date\n"); SetPageUptodate(page); err = 0; } flush_dcache_page(page); UnlockPage(page); DEBUG(2, "blkmtd: readpage: finished, err = %d\n", err); return 0; }