~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/9p/vfs_dir.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * linux/fs/9p/vfs_dir.c
  4  *
  5  * This file contains vfs directory ops for the 9P2000 protocol.
  6  *
  7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  9  */
 10 
 11 #include <linux/module.h>
 12 #include <linux/errno.h>
 13 #include <linux/fs.h>
 14 #include <linux/file.h>
 15 #include <linux/stat.h>
 16 #include <linux/string.h>
 17 #include <linux/sched.h>
 18 #include <linux/inet.h>
 19 #include <linux/idr.h>
 20 #include <linux/slab.h>
 21 #include <linux/uio.h>
 22 #include <net/9p/9p.h>
 23 #include <net/9p/client.h>
 24 
 25 #include "v9fs.h"
 26 #include "v9fs_vfs.h"
 27 #include "fid.h"
 28 
 29 /**
 30  * struct p9_rdir - readdir accounting
 31  * @head: start offset of current dirread buffer
 32  * @tail: end offset of current dirread buffer
 33  * @buf: dirread buffer
 34  *
 35  * private structure for keeping track of readdir
 36  * allocated on demand
 37  */
 38 
 39 struct p9_rdir {
 40         int head;
 41         int tail;
 42         uint8_t buf[];
 43 };
 44 
 45 /**
 46  * dt_type - return file type
 47  * @mistat: mistat structure
 48  *
 49  */
 50 
 51 static inline int dt_type(struct p9_wstat *mistat)
 52 {
 53         unsigned long perm = mistat->mode;
 54         int rettype = DT_REG;
 55 
 56         if (perm & P9_DMDIR)
 57                 rettype = DT_DIR;
 58         if (perm & P9_DMSYMLINK)
 59                 rettype = DT_LNK;
 60 
 61         return rettype;
 62 }
 63 
 64 /**
 65  * v9fs_alloc_rdir_buf - Allocate buffer used for read and readdir
 66  * @filp: opened file structure
 67  * @buflen: Length in bytes of buffer to allocate
 68  *
 69  */
 70 
 71 static struct p9_rdir *v9fs_alloc_rdir_buf(struct file *filp, int buflen)
 72 {
 73         struct p9_fid *fid = filp->private_data;
 74         if (!fid->rdir)
 75                 fid->rdir = kzalloc(sizeof(struct p9_rdir) + buflen, GFP_KERNEL);
 76         return fid->rdir;
 77 }
 78 
 79 /**
 80  * v9fs_dir_readdir - iterate through a directory
 81  * @file: opened file structure
 82  * @ctx: actor we feed the entries to
 83  *
 84  */
 85 
 86 static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
 87 {
 88         bool over;
 89         struct p9_wstat st;
 90         int err = 0;
 91         struct p9_fid *fid;
 92         int buflen;
 93         struct p9_rdir *rdir;
 94         struct kvec kvec;
 95 
 96         p9_debug(P9_DEBUG_VFS, "name %pD\n", file);
 97         fid = file->private_data;
 98 
 99         buflen = fid->clnt->msize - P9_IOHDRSZ;
100 
101         rdir = v9fs_alloc_rdir_buf(file, buflen);
102         if (!rdir)
103                 return -ENOMEM;
104         kvec.iov_base = rdir->buf;
105         kvec.iov_len = buflen;
106 
107         while (1) {
108                 if (rdir->tail == rdir->head) {
109                         struct iov_iter to;
110                         int n;
111                         iov_iter_kvec(&to, READ, &kvec, 1, buflen);
112                         n = p9_client_read(file->private_data, ctx->pos, &to,
113                                            &err);
114                         if (err)
115                                 return err;
116                         if (n == 0)
117                                 return 0;
118 
119                         rdir->head = 0;
120                         rdir->tail = n;
121                 }
122                 while (rdir->head < rdir->tail) {
123                         err = p9stat_read(fid->clnt, rdir->buf + rdir->head,
124                                           rdir->tail - rdir->head, &st);
125                         if (err <= 0) {
126                                 p9_debug(P9_DEBUG_VFS, "returned %d\n", err);
127                                 return -EIO;
128                         }
129 
130                         over = !dir_emit(ctx, st.name, strlen(st.name),
131                                          v9fs_qid2ino(&st.qid), dt_type(&st));
132                         p9stat_free(&st);
133                         if (over)
134                                 return 0;
135 
136                         rdir->head += err;
137                         ctx->pos += err;
138                 }
139         }
140 }
141 
142 /**
143  * v9fs_dir_readdir_dotl - iterate through a directory
144  * @file: opened file structure
145  * @ctx: actor we feed the entries to
146  *
147  */
148 static int v9fs_dir_readdir_dotl(struct file *file, struct dir_context *ctx)
149 {
150         int err = 0;
151         struct p9_fid *fid;
152         int buflen;
153         struct p9_rdir *rdir;
154         struct p9_dirent curdirent;
155 
156         p9_debug(P9_DEBUG_VFS, "name %pD\n", file);
157         fid = file->private_data;
158 
159         buflen = fid->clnt->msize - P9_READDIRHDRSZ;
160 
161         rdir = v9fs_alloc_rdir_buf(file, buflen);
162         if (!rdir)
163                 return -ENOMEM;
164 
165         while (1) {
166                 if (rdir->tail == rdir->head) {
167                         err = p9_client_readdir(fid, rdir->buf, buflen,
168                                                 ctx->pos);
169                         if (err <= 0)
170                                 return err;
171 
172                         rdir->head = 0;
173                         rdir->tail = err;
174                 }
175 
176                 while (rdir->head < rdir->tail) {
177 
178                         err = p9dirent_read(fid->clnt, rdir->buf + rdir->head,
179                                             rdir->tail - rdir->head,
180                                             &curdirent);
181                         if (err < 0) {
182                                 p9_debug(P9_DEBUG_VFS, "returned %d\n", err);
183                                 return -EIO;
184                         }
185 
186                         if (!dir_emit(ctx, curdirent.d_name,
187                                       strlen(curdirent.d_name),
188                                       v9fs_qid2ino(&curdirent.qid),
189                                       curdirent.d_type))
190                                 return 0;
191 
192                         ctx->pos = curdirent.d_off;
193                         rdir->head += err;
194                 }
195         }
196 }
197 
198 
199 /**
200  * v9fs_dir_release - close a directory
201  * @inode: inode of the directory
202  * @filp: file pointer to a directory
203  *
204  */
205 
206 int v9fs_dir_release(struct inode *inode, struct file *filp)
207 {
208         struct p9_fid *fid;
209 
210         fid = filp->private_data;
211         p9_debug(P9_DEBUG_VFS, "inode: %p filp: %p fid: %d\n",
212                  inode, filp, fid ? fid->fid : -1);
213         if (fid)
214                 p9_client_clunk(fid);
215         return 0;
216 }
217 
218 const struct file_operations v9fs_dir_operations = {
219         .read = generic_read_dir,
220         .llseek = generic_file_llseek,
221         .iterate_shared = v9fs_dir_readdir,
222         .open = v9fs_file_open,
223         .release = v9fs_dir_release,
224 };
225 
226 const struct file_operations v9fs_dir_operations_dotl = {
227         .read = generic_read_dir,
228         .llseek = generic_file_llseek,
229         .iterate_shared = v9fs_dir_readdir_dotl,
230         .open = v9fs_file_open,
231         .release = v9fs_dir_release,
232         .fsync = v9fs_file_fsync_dotl,
233 };
234 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp