fs/fuse/virtio_fs.c

3  * virtio-fs: Virtio Filesystem
7 #include <linux/fs.h>
29 /* List of virtio-fs device instances and a lock for the list. Also provides
35 /* The /sys/fs/virtio_fs/ kset */
60 /* A virtio-fs device instance */
148 	struct virtio_fs *fs = vq->vdev->priv;
150 	return &fs->vqs[vq->index];
171 	struct virtio_fs *fs = container_of(kobj, struct virtio_fs, kobj);
173 	return sysfs_emit(buf, "%s\n", fs->tag);
199 static void virtio_fs_put(struct virtio_fs *fs)
201 	kobject_put(&fs->kobj);
234 static void virtio_fs_drain_all_queues_locked(struct virtio_fs *fs)
239 	for (i = 0; i < fs->nvqs; i++) {
240 		fsvq = &fs->vqs[i];
245 static void virtio_fs_drain_all_queues(struct virtio_fs *fs)
254 	virtio_fs_drain_all_queues_locked(fs);
258 static void virtio_fs_start_all_queues(struct virtio_fs *fs)
263 	for (i = 0; i < fs->nvqs; i++) {
264 		fsvq = &fs->vqs[i];
273 				  struct virtio_fs *fs)
281 		if (strcmp(fs->tag, fs2->tag) == 0) {
292 	fs->kobj.kset = virtio_fs_kset;
293 	ret = kobject_add(&fs->kobj, NULL, "%d", vdev->index);
299 	ret = sysfs_create_link(&fs->kobj, &vdev->dev.kobj, "device");
301 		kobject_del(&fs->kobj);
306 	list_add_tail(&fs->list, &virtio_fs_instances);
310 	kobject_uevent(&fs->kobj, KOBJ_ADD);
318 	struct virtio_fs *fs;
322 	list_for_each_entry(fs, &virtio_fs_instances, list) {
323 		if (strcmp(fs->tag, tag) == 0) {
324 			kobject_get(&fs->kobj);
329 	fs = NULL; /* not found */
334 	return fs;
337 static void virtio_fs_free_devs(struct virtio_fs *fs)
341 	for (i = 0; i < fs->nvqs; i++) {
342 		struct virtio_fs_vq *fsvq = &fs->vqs[i];
352 /* Read filesystem name from virtio config into fs->tag (must kfree()). */
353 static int virtio_fs_read_tag(struct virtio_device *vdev, struct virtio_fs *fs)
368 	fs->tag = devm_kmalloc(&vdev->dev, len + 1, GFP_KERNEL);
369 	if (!fs->tag)
371 	memcpy(fs->tag, tag_buf, len);
372 	fs->tag[len] = '\0';
378 	if (strchr(fs->tag, '\n')) {
416 	pr_debug("virtio-fs: worker %s called.\n", __func__);
457 			pr_err("virtio-fs: virtio_fs_enqueue_req() failed %d\n",
493 			pr_debug("virtio-fs: Could not queue FORGET: err=%d. Will try later\n",
503 			pr_debug("virtio-fs: Could not queue FORGET: err=%d. Dropping it.\n",
530 	pr_debug("virtio-fs: worker %s called.\n", __func__);
741 			       struct virtio_fs *fs)
750 			&fs->num_request_queues);
751 	if (fs->num_request_queues == 0)
754 	fs->nvqs = VQ_REQUEST + fs->num_request_queues;
755 	fs->vqs = kcalloc(fs->nvqs, sizeof(fs->vqs[VQ_HIPRIO]), GFP_KERNEL);
756 	if (!fs->vqs)
759 	vqs = kmalloc_array(fs->nvqs, sizeof(vqs[VQ_HIPRIO]), GFP_KERNEL);
760 	callbacks = kmalloc_array(fs->nvqs, sizeof(callbacks[VQ_HIPRIO]),
762 	names = kmalloc_array(fs->nvqs, sizeof(names[VQ_HIPRIO]), GFP_KERNEL);
770 	virtio_fs_init_vq(&fs->vqs[VQ_HIPRIO], "hiprio", VQ_HIPRIO);
771 	names[VQ_HIPRIO] = fs->vqs[VQ_HIPRIO].name;
774 	for (i = VQ_REQUEST; i < fs->nvqs; i++) {
778 		virtio_fs_init_vq(&fs->vqs[i], vq_name, VQ_REQUEST);
780 		names[i] = fs->vqs[i].name;
783 	ret = virtio_find_vqs(vdev, fs->nvqs, vqs, callbacks, names, NULL);
787 	for (i = 0; i < fs->nvqs; i++)
788 		fs->vqs[i].vq = vqs[i];
790 	virtio_fs_start_all_queues(fs);
796 		kfree(fs->vqs);
814 	struct virtio_fs *fs = dax_get_private(dax_dev);
816 	size_t max_nr_pages = fs->window_len / PAGE_SIZE - pgoff;
819 		*kaddr = fs->window_kaddr + offset;
821 		*pfn = phys_to_pfn_t(fs->window_phys_addr + offset,
857 static int virtio_fs_setup_dax(struct virtio_device *vdev, struct virtio_fs *fs)
867 	dax_dev = alloc_dax(fs, &virtio_fs_dax_ops);
908 	fs->window_kaddr = devm_memremap_pages(&vdev->dev, pgmap);
909 	if (IS_ERR(fs->window_kaddr))
910 		return PTR_ERR(fs->window_kaddr);
912 	fs->window_phys_addr = (phys_addr_t) cache_reg.addr;
913 	fs->window_len = (phys_addr_t) cache_reg.len;
916 		__func__, fs->window_kaddr, cache_reg.addr, cache_reg.len);
918 	fs->dax_dev = no_free_ptr(dax_dev);
920 					fs->dax_dev);
925 	struct virtio_fs *fs;
928 	fs = kzalloc(sizeof(*fs), GFP_KERNEL);
929 	if (!fs)
931 	kobject_init(&fs->kobj, &virtio_fs_ktype);
932 	vdev->priv = fs;
934 	ret = virtio_fs_read_tag(vdev, fs);
938 	ret = virtio_fs_setup_vqs(vdev, fs);
944 	ret = virtio_fs_setup_dax(vdev, fs);
953 	ret = virtio_fs_add_instance(vdev, fs);
965 	kobject_put(&fs->kobj);
969 static void virtio_fs_stop_all_queues(struct virtio_fs *fs)
974 	for (i = 0; i < fs->nvqs; i++) {
975 		fsvq = &fs->vqs[i];
984 	struct virtio_fs *fs = vdev->priv;
988 	list_del_init(&fs->list);
989 	sysfs_remove_link(&fs->kobj, "device");
990 	kobject_del(&fs->kobj);
991 	virtio_fs_stop_all_queues(fs);
992 	virtio_fs_drain_all_queues_locked(fs);
998 	virtio_fs_put(fs);
1006 	pr_warn("virtio-fs: suspend/resume not yet supported\n");
1044 	struct virtio_fs *fs;
1051 	fs = fiq->priv;
1052 	fsvq = &fs->vqs[VQ_HIPRIO];
1079 	 * Normal fs operations on a local filesystems aren't interruptible.
1292 	struct virtio_fs *fs;
1304 	fs = fiq->priv;
1311 	fsvq = &fs->vqs[queue_id];
1328 		pr_err("virtio-fs: virtio_fs_enqueue_req() failed %d\n", ret);
1362 	struct virtio_fs *fs = fc->iq.priv;
1375 	if (list_empty(&fs->list)) {
1376 		pr_info("virtio-fs: tag <%s> not found\n", fs->tag);
1382 	for (i = 0; i < fs->nvqs; i++) {
1383 		struct virtio_fs_vq *fsvq = &fs->vqs[i];
1393 		if (ctx->dax_mode == FUSE_DAX_ALWAYS && !fs->dax_dev) {
1395 			pr_err("virtio-fs: dax can't be enabled as filesystem"
1399 		ctx->dax_dev = fs->dax_dev;
1405 	for (i = 0; i < fs->nvqs; i++) {
1406 		struct virtio_fs_vq *fsvq = &fs->vqs[i];
1412 	virtio_fs_start_all_queues(fs);
1418 	virtio_fs_free_devs(fs);
1480 	struct virtio_fs *fs;
1491 	fs = virtio_fs_find_instance(fsc->source);
1492 	if (!fs) {
1493 		pr_info("virtio-fs: tag <%s> not found\n", fsc->source);
1497 	virtqueue_size = virtqueue_get_vring_size(fs->vqs[VQ_REQUEST].vq);
1510 	fuse_conn_init(fc, fm, fsc->user_ns, &virtio_fs_fiq_ops, fs);
1544 	virtio_fs_put(fs);
1579 	const struct virtio_fs *fs = container_of(kobj, struct virtio_fs, kobj);
1581 	add_uevent_var(env, "TAG=%s", fs->tag);