255 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * This file contains vfs directory ops for the 9P2000 protocol.4 *5 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>6 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>7 */8 9#include <linux/module.h>10#include <linux/errno.h>11#include <linux/fs.h>12#include <linux/file.h>13#include <linux/stat.h>14#include <linux/string.h>15#include <linux/sched.h>16#include <linux/slab.h>17#include <linux/uio.h>18#include <linux/fscache.h>19#include <net/9p/9p.h>20#include <net/9p/client.h>21 22#include "v9fs.h"23#include "v9fs_vfs.h"24#include "fid.h"25 26/**27 * struct p9_rdir - readdir accounting28 * @head: start offset of current dirread buffer29 * @tail: end offset of current dirread buffer30 * @buf: dirread buffer31 *32 * private structure for keeping track of readdir33 * allocated on demand34 */35 36struct p9_rdir {37 int head;38 int tail;39 uint8_t buf[];40};41 42/**43 * dt_type - return file type44 * @mistat: mistat structure45 *46 */47 48static inline int dt_type(struct p9_wstat *mistat)49{50 unsigned long perm = mistat->mode;51 int rettype = DT_REG;52 53 if (perm & P9_DMDIR)54 rettype = DT_DIR;55 if (perm & P9_DMSYMLINK)56 rettype = DT_LNK;57 58 return rettype;59}60 61/**62 * v9fs_alloc_rdir_buf - Allocate buffer used for read and readdir63 * @filp: opened file structure64 * @buflen: Length in bytes of buffer to allocate65 *66 */67 68static struct p9_rdir *v9fs_alloc_rdir_buf(struct file *filp, int buflen)69{70 struct p9_fid *fid = filp->private_data;71 72 if (!fid->rdir)73 fid->rdir = kzalloc(sizeof(struct p9_rdir) + buflen, GFP_KERNEL);74 return fid->rdir;75}76 77/**78 * v9fs_dir_readdir - iterate through a directory79 * @file: opened file structure80 * @ctx: actor we feed the entries to81 *82 */83 84static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)85{86 bool over;87 struct p9_wstat st;88 int err = 0;89 struct p9_fid *fid;90 int buflen;91 struct p9_rdir *rdir;92 struct kvec kvec;93 94 p9_debug(P9_DEBUG_VFS, "name %pD\n", file);95 fid = file->private_data;96 97 buflen = fid->clnt->msize - P9_IOHDRSZ;98 99 rdir = v9fs_alloc_rdir_buf(file, buflen);100 if (!rdir)101 return -ENOMEM;102 kvec.iov_base = rdir->buf;103 kvec.iov_len = buflen;104 105 while (1) {106 if (rdir->tail == rdir->head) {107 struct iov_iter to;108 int n;109 110 iov_iter_kvec(&to, ITER_DEST, &kvec, 1, buflen);111 n = p9_client_read(file->private_data, ctx->pos, &to,112 &err);113 if (err)114 return err;115 if (n == 0)116 return 0;117 118 rdir->head = 0;119 rdir->tail = n;120 }121 while (rdir->head < rdir->tail) {122 err = p9stat_read(fid->clnt, rdir->buf + rdir->head,123 rdir->tail - rdir->head, &st);124 if (err <= 0) {125 p9_debug(P9_DEBUG_VFS, "returned %d\n", err);126 return -EIO;127 }128 129 over = !dir_emit(ctx, st.name, strlen(st.name),130 QID2INO(&st.qid), dt_type(&st));131 p9stat_free(&st);132 if (over)133 return 0;134 135 rdir->head += err;136 ctx->pos += err;137 }138 }139}140 141/**142 * v9fs_dir_readdir_dotl - iterate through a directory143 * @file: opened file structure144 * @ctx: actor we feed the entries to145 *146 */147static int v9fs_dir_readdir_dotl(struct file *file, struct dir_context *ctx)148{149 int err = 0;150 struct p9_fid *fid;151 int buflen;152 struct p9_rdir *rdir;153 struct p9_dirent curdirent;154 155 p9_debug(P9_DEBUG_VFS, "name %pD\n", file);156 fid = file->private_data;157 158 buflen = fid->clnt->msize - P9_READDIRHDRSZ;159 160 rdir = v9fs_alloc_rdir_buf(file, buflen);161 if (!rdir)162 return -ENOMEM;163 164 while (1) {165 if (rdir->tail == rdir->head) {166 err = p9_client_readdir(fid, rdir->buf, buflen,167 ctx->pos);168 if (err <= 0)169 return err;170 171 rdir->head = 0;172 rdir->tail = err;173 }174 175 while (rdir->head < rdir->tail) {176 177 err = p9dirent_read(fid->clnt, rdir->buf + rdir->head,178 rdir->tail - rdir->head,179 &curdirent);180 if (err < 0) {181 p9_debug(P9_DEBUG_VFS, "returned %d\n", err);182 return -EIO;183 }184 185 if (!dir_emit(ctx, curdirent.d_name,186 strlen(curdirent.d_name),187 QID2INO(&curdirent.qid),188 curdirent.d_type))189 return 0;190 191 ctx->pos = curdirent.d_off;192 rdir->head += err;193 }194 }195}196 197 198/**199 * v9fs_dir_release - close a directory or a file200 * @inode: inode of the directory or file201 * @filp: file pointer to a directory or file202 *203 */204 205int v9fs_dir_release(struct inode *inode, struct file *filp)206{207 struct v9fs_inode *v9inode = V9FS_I(inode);208 struct p9_fid *fid;209 __le32 version;210 loff_t i_size;211 int retval = 0, put_err;212 213 fid = filp->private_data;214 p9_debug(P9_DEBUG_VFS, "inode: %p filp: %p fid: %d\n",215 inode, filp, fid ? fid->fid : -1);216 217 if (fid) {218 if ((S_ISREG(inode->i_mode)) && (filp->f_mode & FMODE_WRITE))219 retval = filemap_fdatawrite(inode->i_mapping);220 221 spin_lock(&inode->i_lock);222 hlist_del(&fid->ilist);223 spin_unlock(&inode->i_lock);224 put_err = p9_fid_put(fid);225 retval = retval < 0 ? retval : put_err;226 }227 228 if ((filp->f_mode & FMODE_WRITE)) {229 version = cpu_to_le32(v9inode->qid.version);230 i_size = i_size_read(inode);231 fscache_unuse_cookie(v9fs_inode_cookie(v9inode),232 &version, &i_size);233 } else {234 fscache_unuse_cookie(v9fs_inode_cookie(v9inode), NULL, NULL);235 }236 return retval;237}238 239const struct file_operations v9fs_dir_operations = {240 .read = generic_read_dir,241 .llseek = generic_file_llseek,242 .iterate_shared = v9fs_dir_readdir,243 .open = v9fs_file_open,244 .release = v9fs_dir_release,245};246 247const struct file_operations v9fs_dir_operations_dotl = {248 .read = generic_read_dir,249 .llseek = generic_file_llseek,250 .iterate_shared = v9fs_dir_readdir_dotl,251 .open = v9fs_file_open,252 .release = v9fs_dir_release,253 .fsync = v9fs_file_fsync_dotl,254};255