static int ps3flash_fsync(struct file *file, loff_t start, loff_t end, int datasync) { struct inode *inode = file->f_path.dentry->d_inode; int err; mutex_lock(&inode->i_mutex); err = ps3flash_writeback(ps3flash_dev); mutex_unlock(&inode->i_mutex); return err; }
static ssize_t ps3flash_kernel_write(const void *buf, size_t count, loff_t pos) { ssize_t res; int wb; res = ps3flash_write(NULL, buf, count, &pos); if (res < 0) return res; /* Make kernel writes synchronous */ wb = ps3flash_writeback(ps3flash_dev); if (wb) return wb; return res; }
static int ps3flash_fetch(struct ps3_storage_device *dev, u64 start_sector) { struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); int res; if (start_sector == priv->tag) return 0; res = ps3flash_writeback(dev); if (res) return res; priv->tag = -1; res = ps3flash_read_write_sectors(dev, start_sector, 0); if (res) return res; priv->tag = start_sector; return 0; }
static int ps3flash_flush(struct file *file, fl_owner_t id) { return ps3flash_writeback(ps3flash_dev); }
static ssize_t ps3flash_write(const char __user *userbuf, const void *kernelbuf, size_t count, loff_t *pos) { struct ps3_storage_device *dev = ps3flash_dev; struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); u64 size, sector, offset; int res = 0; size_t remaining, n; void *dst; dev_dbg(&dev->sbd.core, "%s:%u: Writing %zu bytes at position %lld from U0x%p/K0x%p\n", __func__, __LINE__, count, *pos, userbuf, kernelbuf); size = dev->regions[dev->region_idx].size*dev->blk_size; if (*pos >= size || !count) return 0; if (*pos + count > size) { dev_dbg(&dev->sbd.core, "%s:%u Truncating count from %zu to %llu\n", __func__, __LINE__, count, size - *pos); count = size - *pos; } sector = *pos / dev->bounce_size * priv->chunk_sectors; offset = *pos % dev->bounce_size; remaining = count; do { n = min_t(u64, remaining, dev->bounce_size - offset); dst = dev->bounce_buf + offset; mutex_lock(&priv->mutex); if (n != dev->bounce_size) res = ps3flash_fetch(dev, sector); else if (sector != priv->tag) res = ps3flash_writeback(dev); if (res) goto fail; dev_dbg(&dev->sbd.core, "%s:%u: copy %lu bytes from U0x%p/K0x%p to 0x%p\n", __func__, __LINE__, n, userbuf, kernelbuf, dst); if (userbuf) { if (copy_from_user(dst, userbuf, n)) { res = -EFAULT; goto fail; } userbuf += n; } if (kernelbuf) { memcpy(dst, kernelbuf, n); kernelbuf += n; } priv->tag = sector; priv->dirty = true; mutex_unlock(&priv->mutex); *pos += n; remaining -= n; sector += priv->chunk_sectors; offset = 0; } while (remaining > 0); return count; fail: mutex_unlock(&priv->mutex); return res; }
static int ps3flash_fsync(struct file *file, struct dentry *dentry, int datasync) { return ps3flash_writeback(ps3flash_dev); }