自学教程：C++ vfs_readdir函数代码示例

static int wrapfs_readdir(struct file *file, void *dirent, filldir_t filldir){	int err = 0;	struct file *lower_file = NULL;	struct dentry *wrapfs_dentry = file->f_path.dentry;#ifdef EXTRA_CREDIT	struct wrapfs_getdents_callback buf;		if(wrapfs_get_debug(file->f_dentry->d_sb) & DEBUG_FILE)		DEBUG_MESG("Enter");#endif	lower_file = wrapfs_lower_file(file);	// lower_file->f_pos = file->f_pos;#ifdef EXTRA_CREDIT	if(wrapfs_get_debug(file->f_dentry->d_sb) & DEBUG_OTHER)		DEBUG_MESG("Encrypting and Decrypting filenames");	memset(&buf, 0, sizeof(buf));	buf.dirent = dirent;	buf.dentry = wrapfs_dentry;	buf.filldir = filldir;	buf.filldir_called = 0;	buf.entries_written = 0;	err = vfs_readdir(lower_file, wrapfs_filldir, (void *)&buf);	if(err<0)		goto out;	if(buf.filldir_called && !buf.entries_written) {		printk(KERN_ERR "wrapfs_readdir: filldir called but entries not written/n");		goto out;	}#else	err = vfs_readdir(lower_file, filldir, dirent);#endif	file->f_pos = lower_file->f_pos;	if (err >= 0)		/* copy the atime */		fsstack_copy_attr_atime(wrapfs_dentry->d_inode, lower_file->f_path.dentry->d_inode);#ifdef EXTRA_CREDIT	if(wrapfs_get_debug(file->f_dentry->d_sb) & DEBUG_FILE)		DEBUG_RETURN("Exit", err);out:#endif	return err;}

static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldir){    struct dentry *dentry = file->f_dentry;    struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);    int status;    DPRINTK("file=%p dentry=%p %.*s",            file, dentry, dentry->d_name.len, dentry->d_name.name);    if (autofs4_oz_mode(sbi))        goto out;    if (autofs4_ispending(dentry)) {        DPRINTK("dentry busy");        return -EBUSY;    }    if (d_mountpoint(dentry)) {        struct file *fp = file->private_data;        if (!fp)            return -ENOENT;        if (!fp->f_op || !fp->f_op->readdir)            goto out;        status = vfs_readdir(fp, filldir, dirent);        file->f_pos = fp->f_pos;        if (status)            autofs4_copy_atime(file, fp);        return status;    }out:    return autofs4_dcache_readdir(file, dirent, filldir);}

int hpux_getdents(unsigned int fd, struct hpux_dirent __user *dirent, unsigned int count){	struct file * file;	struct hpux_dirent __user * lastdirent;	struct getdents_callback buf;	int error = -EBADF;	file = fget(fd);	if (!file)		goto out;	buf.current_dir = dirent;	buf.previous = NULL;	buf.count = count;	buf.error = 0;	error = vfs_readdir(file, filldir, &buf);	if (error >= 0)		error = buf.error;	lastdirent = buf.previous;	if (lastdirent) {		if (put_user(file->f_pos, &lastdirent->d_off))			error = -EFAULT;		else			error = count - buf.count;	}	fput(file);out:	return error;}

static int wrapfs_readdir(struct file *file, void *dirent, filldir_t filldir){	int err = 0;	struct file *lower_file = NULL;	struct dentry *dentry = file->f_path.dentry;	struct dentry *parent;	struct inode *inode = NULL;	int bindex = 0;	inode = dentry->d_inode;	parent = dget_parent(dentry);	for (bindex = 0; bindex <= 1; bindex++) {		lower_file = wrapfs_lower_file_idx(file, bindex);		if (!lower_file)			continue;		err = vfs_readdir(lower_file, filldir, dirent);		file->f_pos = lower_file->f_pos;		if (err >= 0) {			/* copy the atime */			fsstack_copy_attr_atime(dentry->d_inode,				lower_file->f_path.dentry->d_inode);			}		}	dput(parent);	return err;}

static void fat_mmc_test_process_line(tstr_t *line){    if (!tstr_cmp(line, &S("dir")))        vfs_readdir(&S("FAT/"), fat_mmc_test_readdir_cb, NULL);    console_printf("Ok/n");}

int sys_readdir (uint_t fd, struct vfs_dirent_s *dirent){	error_t err;	struct task_s *task;	struct thread_s *this;	struct vfs_file_s *file;  	task = current_task;	this = current_thread;	if((dirent == NULL)                || 	   (fd >= CONFIG_TASK_FILE_MAX_NR) || 	   (task_fd_lookup(task,fd) == NULL))	{		this->info.errno = EBADFD;		return -1;	}	file = task_fd_lookup(task,fd);   	if((err = vfs_readdir(file, dirent)))	{		this->info.errno = (err < 0) ? -err : err; 		return -1;	}   	return 0;}

asmlinkage longsys32_getdents (unsigned int fd, void __user * dirent, unsigned int count){	struct file * file;	struct linux32_dirent __user * lastdirent;	struct getdents32_callback buf;	int error;	error = -EBADF;	file = fget(fd);	if (!file)		goto out;	buf.current_dir = (struct linux32_dirent __user *) dirent;	buf.previous = NULL;	buf.count = count;	buf.error = 0;	error = vfs_readdir(file, filldir32, &buf);	if (error < 0)		goto out_putf;	error = buf.error;	lastdirent = buf.previous;	if (lastdirent) {		put_user(file->f_pos, &lastdirent->d_off);		error = count - buf.count;	}out_putf:	fput(file);out:	return error;}

/* file operations for directories */int coda_readdir(struct file *coda_file, void *dirent, filldir_t filldir){	struct dentry *coda_dentry = coda_file->f_dentry;	struct coda_file_info *cfi;	struct file *host_file;	int ret;	cfi = CODA_FTOC(coda_file);	if (!cfi || cfi->cfi_magic != CODA_MAGIC) BUG();	host_file = cfi->cfi_container;	coda_vfs_stat.readdir++;	down(&host_file->f_dentry->d_inode->i_sem);	host_file->f_pos = coda_file->f_pos;	if ( !host_file->f_op->readdir ) {		/* Venus: we must read Venus dirents from the file */		ret = coda_venus_readdir(host_file, filldir, dirent, coda_dentry);	} else {		/* potemkin case: we were handed a directory inode */		ret = vfs_readdir(host_file, filldir, dirent);	}	coda_file->f_pos = host_file->f_pos;	up(&host_file->f_dentry->d_inode->i_sem);	return ret;}

/** * ecryptfs_readdir * @file: The eCryptfs directory file * @dirent: Directory entry handle * @filldir: The filldir callback function */static int ecryptfs_readdir(struct file *file, void *dirent, filldir_t filldir){	int rc;	struct file *lower_file;	struct inode *inode;	struct ecryptfs_getdents_callback buf;	lower_file = ecryptfs_file_to_lower(file);	lower_file->f_pos = file->f_pos;	inode = file->f_path.dentry->d_inode;	memset(&buf, 0, sizeof(buf));	buf.dirent = dirent;	buf.dentry = file->f_path.dentry;	buf.filldir = filldir;	buf.filldir_called = 0;	buf.entries_written = 0;	rc = vfs_readdir(lower_file, ecryptfs_filldir, (void *)&buf);	file->f_pos = lower_file->f_pos;	if (rc < 0)		goto out;	if (buf.filldir_called && !buf.entries_written)		goto out;	if (rc >= 0)		fsstack_copy_attr_atime(inode,					lower_file->f_path.dentry->d_inode);out:	return rc;}

void op_ls(const char **params, int nparams) {  assert(nparams > 0);  inode_t *ino = vfs_open(params[0], &dummy_access);  assert(ino && "File not found!");  vector_t files = vfs_readdir(ino);  for (unsigned i = 0; i < vector_length(&files); ++i) {    dirent_t *dent = vector_get(&files, i);    const char *c;    switch (dent->ino->type) {    case it_file: c = "FILE"; break;    case it_dir: c = "DIR"; break;    case it_chardev: c = "CDEV"; break;    case it_blockdev: c = "BDEV"; break;    case it_fifo: c = "FIFO"; break;    case it_socket: c = "SOCK"; break;    default: assert(0);    }    kprintf("[[%s]] %s : nlink %d mode %x ctime %d mtime %d atime %d uid %d gid %d size %d/n",            c,            dent->name,            dent->ino->nlink, dent->ino->mode,            dent->ino->ctime, dent->ino->mtime, dent->ino->atime,            dent->ino->uid, dent->ino->gid, dent->ino->size);  }}

int vfsub_readdir(struct file *file, filldir_t filldir, void *arg){	int err;	err = vfs_readdir(file, filldir, arg);	if (err >= 0)		vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/	return err;}

int _ls_handler(int argc, char **argv){    if (argc < 2) {        _ls_usage(argv);        return 1;    }    char *path = argv[1];    uint8_t buf[16];    int res;    int ret = 0;    res = vfs_normalize_path(path, path, strlen(path) + 1);    if (res < 0) {        _errno_string(res, (char *)buf, sizeof(buf));        printf("Invalid path /"%s/": %s/n", path, buf);        return 5;    }    vfs_DIR dir;    res = vfs_opendir(&dir, path);    if (res < 0) {        _errno_string(res, (char *)buf, sizeof(buf));        printf("vfs_opendir error: %s/n", buf);        return 1;    }    unsigned int nfiles = 0;    while (1) {        vfs_dirent_t entry;        res = vfs_readdir(&dir, &entry);        if (res < 0) {            _errno_string(res, (char *)buf, sizeof(buf));            printf("vfs_readdir error: %s/n", buf);            if (res == -EAGAIN) {                /* try again */                continue;            }            ret = 2;            break;        }        if (res == 0) {            /* end of stream */            break;        }        printf("%s/n", entry.d_name);        ++nfiles;    }    if (ret == 0) {        printf("total %u files/n", nfiles);    }    res = vfs_closedir(&dir);    if (res < 0) {        _errno_string(res, (char *)buf, sizeof(buf));        printf("vfs_closedir error: %s/n", buf);        return 2;    }    return ret;}

/** * get_name - default export_operations->get_name function * @dentry: the directory in which to find a name * @name:   a pointer to a %NAME_MAX+1 char buffer to store the name * @child:  the dentry for the child directory. * * calls readdir on the parent until it finds an entry with * the same inode number as the child, and returns that. */static int get_name(struct dentry *dentry, char *name,			struct dentry *child){	struct inode *dir = dentry->d_inode;	int error;	struct file *file;	struct getdents_callback buffer;	error = -ENOTDIR;	if (!dir || !S_ISDIR(dir->i_mode))		goto out;	error = -EINVAL;	if (!dir->i_fop)		goto out;	/*	 * Open the directory ...	 */	file = dentry_open(dget(dentry), NULL, O_RDONLY);	error = PTR_ERR(file);	if (IS_ERR(file))		goto out;	error = -EINVAL;	if (!file->f_op->readdir)		goto out_close;	buffer.name = name;	buffer.ino = child->d_inode->i_ino;	buffer.found = 0;	buffer.sequence = 0;	while (1) {		int old_seq = buffer.sequence;		error = vfs_readdir(file, filldir_one, &buffer);		if (error < 0)			break;		error = 0;		if (buffer.found)			break;		error = -ENOENT;		if (old_seq == buffer.sequence)			break;	}out_close:	fput(file);out:	return error;}

/** * nfsd_get_name - default nfsd_operations->get_name function * @dentry: the directory in which to find a name * @name:   a pointer to a %NAME_MAX+1 char buffer to store the name * @child:  the dentry for the child directory. * * calls readdir on the parent until it finds an entry with * the same inode number as the child, and returns that. */static int nfsd_get_name(struct dentry *dentry, char *name,			struct dentry *child){	struct inode *dir = dentry->d_inode;	int error;	struct file file;	struct nfsd_getdents_callback buffer;	error = -ENOTDIR;	if (!dir || !S_ISDIR(dir->i_mode))		goto out;	error = -EINVAL;	if (!dir->i_fop)		goto out;	/*	 * Open the directory ...	 */	error = init_private_file(&file, dentry, FMODE_READ);	if (error)		goto out;	error = -EINVAL;	if (!file.f_op->readdir)		goto out_close;	buffer.name = name;	buffer.ino = child->d_inode->i_ino;	buffer.found = 0;	buffer.sequence = 0;	while (1) {		int old_seq = buffer.sequence;		error = vfs_readdir(&file, filldir_one, &buffer);		if (error < 0)			break;		error = 0;		if (buffer.found)			break;		error = -ENOENT;		if (old_seq == buffer.sequence)			break;	}out_close:	if (file.f_op->release)		file.f_op->release(dir, &file);out:	return error;}

static int wrapfs_readdir(struct file *file, void *dirent, filldir_t filldir){	int err = 0;	struct file *lower_file = NULL;	struct dentry *dentry = file->f_path.dentry;	lower_file = wrapfs_lower_file(file);	err = vfs_readdir(lower_file, filldir, dirent);	file->f_pos = lower_file->f_pos;	if (err >= 0)		/* copy the atime */		fsstack_copy_attr_atime(dentry->d_inode,					lower_file->f_path.dentry->d_inode);	return err;}

int do_vfsub_readdir(struct file *file, filldir_t filldir, void *arg){	int err;	LKTRTrace("%.*s/n", AuDLNPair(file->f_dentry));	lockdep_off();	err = vfs_readdir(file, filldir, arg);	lockdep_on();	if (err >= 0)		au_update_fuse_h_inode(file->f_vfsmnt, file->f_dentry);	/*ignore*/	return err;}

/* * scfs_readdir */static int scfs_readdir(struct file *file, void *dirent, filldir_t filldir){	struct file *lower_file = NULL;	struct dentry *dentry = file->f_path.dentry;	int ret = 0;	lower_file = scfs_lower_file(file);	lower_file->f_pos = file->f_pos;	ret = vfs_readdir(lower_file, filldir, dirent);	file->f_pos = lower_file->f_pos;	if (ret >= 0)		fsstack_copy_attr_atime(dentry->d_inode, lower_file->f_path.dentry->d_inode);	return ret;}

/** * lofs_readdir * @file:       The lofs directory file. * @dirent:     Buffer to fill with directory entries. * @filldir:    The filldir callback function */static int lofs_readdir(struct file *file, void *dirent, filldir_t filldir){        int rc;        struct file *lower_file;        struct inode *inode;        lower_file = lofs_file_to_lower(file);        if (lower_file->f_pos != file->f_pos) {            vfs_llseek(lower_file, file->f_pos, 0 /* SEEK_SET */);        }        inode = FILE_TO_DENTRY(file)->d_inode;        rc = vfs_readdir(lower_file, filldir, dirent);        file->f_pos = lower_file->f_pos;        if (rc >= 0) {            fsstack_copy_attr_atime(inode,FILE_TO_DENTRY(lower_file)->d_inode);        }        return rc;}

static intnfsd4_list_rec_dir(struct dentry *dir, recdir_func *f){	struct file *filp;	struct dentry_list_arg dla = {		.parent = dir,	};	struct list_head *dentries = &dla.dentries;	struct dentry_list *child;	uid_t uid;	gid_t gid;	int status;	if (!rec_dir_init)		return 0;	nfs4_save_user(&uid, &gid);	filp = dentry_open(dget(dir), mntget(rec_dir.mnt), O_RDONLY);	status = PTR_ERR(filp);	if (IS_ERR(filp))		goto out;	INIT_LIST_HEAD(dentries);	status = vfs_readdir(filp, nfsd4_build_dentrylist, &dla);	fput(filp);	while (!list_empty(dentries)) {		child = list_entry(dentries->next, struct dentry_list, list);		status = f(dir, child->dentry);		if (status)			goto out;		list_del(&child->list);		dput(child->dentry);		kfree(child);	}out:	while (!list_empty(dentries)) {		child = list_entry(dentries->next, struct dentry_list, list);		list_del(&child->list);		dput(child->dentry);		kfree(child);	}	nfs4_reset_user(uid, gid);	return status;}

long l_readdir(struct file *file, cfs_list_t *dentry_list){        struct l_linux_dirent *lastdirent;        struct l_readdir_callback buf;        int error;        buf.lrc_dirent = NULL;        buf.lrc_list = dentry_list;        error = vfs_readdir(file, l_filldir, &buf);        if (error < 0)                return error;        lastdirent = buf.lrc_dirent;        if (lastdirent)                lastdirent->lld_off = file->f_pos;        return 0;}

static int fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,                       off_t offset, struct fuse_file_info *fi){    dirent *de;    filler(buf, ".", NULL, 0);    filler(buf, "..", NULL, 0);    vfs_seekdir(fi->fh, offset);    while ((de = vfs_readdir(fi->fh)) != NULL) {        stat st;        memset(&st, 0, sizeof(st));        st.st_ino = de->d_ino;        st.st_mode = de->d_type << 12;        if (filler(buf, de->d_name, &st, 0))            break;    }    return 0;}

struct vnode *vfs_lookup(struct vnode *parent, char *name){    parent = get_real_node(parent);    DIR *dh = vfs_opendir(parent);    struct vnode *node = 0;    while ((node = vfs_readdir(dh)) != NULL)    {        if (!strcmp(node->v_name, name))        {            vfs_closedir(dh);            return node;        }    }    vfs_closedir(dh);    return NULL;}

asmlinkage int sunos_getdirentries(unsigned int fd, u32 u_dirent,				   int cnt, u32 u_basep){	void *dirent = (void *) A(u_dirent);	unsigned int *basep = (unsigned int *)A(u_basep);	struct file * file;	struct sunos_direntry * lastdirent;	int error = -EBADF;	struct sunos_direntry_callback buf;	if(fd >= SUNOS_NR_OPEN)		goto out;	file = fget(fd);	if(!file)		goto out;	error = -EINVAL;	if(cnt < (sizeof(struct sunos_direntry) + 255))		goto out_putf;	buf.curr = (struct sunos_direntry *) dirent;	buf.previous = NULL;	buf.count = cnt;	buf.error = 0;	error = vfs_readdir(file, sunos_filldirentry, &buf);	if (error < 0)		goto out_putf;	lastdirent = buf.previous;	error = buf.error;	if (lastdirent) {		put_user(file->f_pos, basep);		error = cnt - buf.count;	}out_putf:	fput(file);out:	return error;}

SYSCALL_DEFINE3(old_readdir, unsigned int, fd,		struct old_linux_dirent __user *, dirent, unsigned int, count){	int error;	struct fd f = fdget(fd);	struct readdir_callback buf;	if (!f.file)		return -EBADF;	buf.result = 0;	buf.dirent = dirent;	error = vfs_readdir(f.file, fillonedir, &buf);	if (buf.result)		error = buf.result;	fdput(f);	return error;}