linux/fs/9p/vfs_dir.c
<<
>>
Prefs
   1/*
   2 * linux/fs/9p/vfs_dir.c
   3 *
   4 * This file contains vfs directory ops for the 9P2000 protocol.
   5 *
   6 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   7 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   8 *
   9 *  This program is free software; you can redistribute it and/or modify
  10 *  it under the terms of the GNU General Public License version 2
  11 *  as published by the Free Software Foundation.
  12 *
  13 *  This program is distributed in the hope that it will be useful,
  14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *  GNU General Public License for more details.
  17 *
  18 *  You should have received a copy of the GNU General Public License
  19 *  along with this program; if not, write to:
  20 *  Free Software Foundation
  21 *  51 Franklin Street, Fifth Floor
  22 *  Boston, MA  02111-1301  USA
  23 *
  24 */
  25
  26#include <linux/module.h>
  27#include <linux/errno.h>
  28#include <linux/fs.h>
  29#include <linux/file.h>
  30#include <linux/stat.h>
  31#include <linux/string.h>
  32#include <linux/sched.h>
  33#include <linux/inet.h>
  34#include <linux/idr.h>
  35#include <linux/slab.h>
  36#include <net/9p/9p.h>
  37#include <net/9p/client.h>
  38
  39#include "v9fs.h"
  40#include "v9fs_vfs.h"
  41#include "fid.h"
  42
  43/**
  44 * struct p9_rdir - readdir accounting
  45 * @mutex: mutex protecting readdir
  46 * @head: start offset of current dirread buffer
  47 * @tail: end offset of current dirread buffer
  48 * @buf: dirread buffer
  49 *
  50 * private structure for keeping track of readdir
  51 * allocated on demand
  52 */
  53
  54struct p9_rdir {
  55        int head;
  56        int tail;
  57        uint8_t buf[];
  58};
  59
  60/**
  61 * dt_type - return file type
  62 * @mistat: mistat structure
  63 *
  64 */
  65
  66static inline int dt_type(struct p9_wstat *mistat)
  67{
  68        unsigned long perm = mistat->mode;
  69        int rettype = DT_REG;
  70
  71        if (perm & P9_DMDIR)
  72                rettype = DT_DIR;
  73        if (perm & P9_DMSYMLINK)
  74                rettype = DT_LNK;
  75
  76        return rettype;
  77}
  78
  79static void p9stat_init(struct p9_wstat *stbuf)
  80{
  81        stbuf->name  = NULL;
  82        stbuf->uid   = NULL;
  83        stbuf->gid   = NULL;
  84        stbuf->muid  = NULL;
  85        stbuf->extension = NULL;
  86}
  87
  88/**
  89 * v9fs_alloc_rdir_buf - Allocate buffer used for read and readdir
  90 * @filp: opened file structure
  91 * @buflen: Length in bytes of buffer to allocate
  92 *
  93 */
  94
  95static struct p9_rdir *v9fs_alloc_rdir_buf(struct file *filp, int buflen)
  96{
  97        struct p9_fid *fid = filp->private_data;
  98        if (!fid->rdir)
  99                fid->rdir = kzalloc(sizeof(struct p9_rdir) + buflen, GFP_KERNEL);
 100        return fid->rdir;
 101}
 102
 103/**
 104 * v9fs_dir_readdir - iterate through a directory
 105 * @file: opened file structure
 106 * @ctx: actor we feed the entries to
 107 *
 108 */
 109
 110static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
 111{
 112        bool over;
 113        struct p9_wstat st;
 114        int err = 0;
 115        struct p9_fid *fid;
 116        int buflen;
 117        int reclen = 0;
 118        struct p9_rdir *rdir;
 119
 120        p9_debug(P9_DEBUG_VFS, "name %s\n", file->f_path.dentry->d_name.name);
 121        fid = file->private_data;
 122
 123        buflen = fid->clnt->msize - P9_IOHDRSZ;
 124
 125        rdir = v9fs_alloc_rdir_buf(file, buflen);
 126        if (!rdir)
 127                return -ENOMEM;
 128
 129        while (1) {
 130                if (rdir->tail == rdir->head) {
 131                        err = v9fs_file_readn(file, rdir->buf, NULL,
 132                                                        buflen, ctx->pos);
 133                        if (err <= 0)
 134                                return err;
 135
 136                        rdir->head = 0;
 137                        rdir->tail = err;
 138                }
 139                while (rdir->head < rdir->tail) {
 140                        p9stat_init(&st);
 141                        err = p9stat_read(fid->clnt, rdir->buf + rdir->head,
 142                                          rdir->tail - rdir->head, &st);
 143                        if (err) {
 144                                p9_debug(P9_DEBUG_VFS, "returned %d\n", err);
 145                                p9stat_free(&st);
 146                                return -EIO;
 147                        }
 148                        reclen = st.size+2;
 149
 150                        over = !dir_emit(ctx, st.name, strlen(st.name),
 151                                         v9fs_qid2ino(&st.qid), dt_type(&st));
 152                        p9stat_free(&st);
 153                        if (over)
 154                                return 0;
 155
 156                        rdir->head += reclen;
 157                        ctx->pos += reclen;
 158                }
 159        }
 160}
 161
 162/**
 163 * v9fs_dir_readdir_dotl - iterate through a directory
 164 * @file: opened file structure
 165 * @ctx: actor we feed the entries to
 166 *
 167 */
 168static int v9fs_dir_readdir_dotl(struct file *file, struct dir_context *ctx)
 169{
 170        int err = 0;
 171        struct p9_fid *fid;
 172        int buflen;
 173        struct p9_rdir *rdir;
 174        struct p9_dirent curdirent;
 175
 176        p9_debug(P9_DEBUG_VFS, "name %s\n", file->f_path.dentry->d_name.name);
 177        fid = file->private_data;
 178
 179        buflen = fid->clnt->msize - P9_READDIRHDRSZ;
 180
 181        rdir = v9fs_alloc_rdir_buf(file, buflen);
 182        if (!rdir)
 183                return -ENOMEM;
 184
 185        while (1) {
 186                if (rdir->tail == rdir->head) {
 187                        err = p9_client_readdir(fid, rdir->buf, buflen,
 188                                                ctx->pos);
 189                        if (err <= 0)
 190                                return err;
 191
 192                        rdir->head = 0;
 193                        rdir->tail = err;
 194                }
 195
 196                while (rdir->head < rdir->tail) {
 197
 198                        err = p9dirent_read(fid->clnt, rdir->buf + rdir->head,
 199                                            rdir->tail - rdir->head,
 200                                            &curdirent);
 201                        if (err < 0) {
 202                                p9_debug(P9_DEBUG_VFS, "returned %d\n", err);
 203                                return -EIO;
 204                        }
 205
 206                        if (!dir_emit(ctx, curdirent.d_name,
 207                                      strlen(curdirent.d_name),
 208                                      v9fs_qid2ino(&curdirent.qid),
 209                                      curdirent.d_type))
 210                                return 0;
 211
 212                        ctx->pos = curdirent.d_off;
 213                        rdir->head += err;
 214                }
 215        }
 216}
 217
 218
 219/**
 220 * v9fs_dir_release - close a directory
 221 * @inode: inode of the directory
 222 * @filp: file pointer to a directory
 223 *
 224 */
 225
 226int v9fs_dir_release(struct inode *inode, struct file *filp)
 227{
 228        struct p9_fid *fid;
 229
 230        fid = filp->private_data;
 231        p9_debug(P9_DEBUG_VFS, "inode: %p filp: %p fid: %d\n",
 232                 inode, filp, fid ? fid->fid : -1);
 233        if (fid)
 234                p9_client_clunk(fid);
 235        return 0;
 236}
 237
 238const struct file_operations v9fs_dir_operations = {
 239        .read = generic_read_dir,
 240        .llseek = generic_file_llseek,
 241        .iterate = v9fs_dir_readdir,
 242        .open = v9fs_file_open,
 243        .release = v9fs_dir_release,
 244};
 245
 246const struct file_operations v9fs_dir_operations_dotl = {
 247        .read = generic_read_dir,
 248        .llseek = generic_file_llseek,
 249        .iterate = v9fs_dir_readdir_dotl,
 250        .open = v9fs_file_open,
 251        .release = v9fs_dir_release,
 252        .fsync = v9fs_file_fsync_dotl,
 253};
 254
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.