URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [bfs/] [dir.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *      fs/bfs/dir.c
 *      BFS directory operations.
 *      Copyright (C) 1999,2000  Tigran Aivazian <tigran@veritas.com>
 */
 
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/bfs_fs.h>
#include <linux/locks.h>
 
#include "bfs_defs.h"
 
#undef DEBUG
 
#ifdef DEBUG
#define dprintf(x...)   printf(x)
#else
#define dprintf(x...)
#endif
 
static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino);
static struct buffer_head * bfs_find_entry(struct inode * dir,
        const char * name, int namelen, struct bfs_dirent ** res_dir);
 
static int bfs_readdir(struct file * f, void * dirent, filldir_t filldir)
{
        struct inode * dir = f->f_dentry->d_inode;
        struct buffer_head * bh;
        struct bfs_dirent * de;
        kdev_t dev = dir->i_dev;
        unsigned int offset;
        int block;
 
        if (f->f_pos & (BFS_DIRENT_SIZE-1)) {
                printf("Bad f_pos=%08lx for %s:%08lx\n", (unsigned long)f->f_pos,
                        bdevname(dev), dir->i_ino);
                return -EBADF;
        }
 
        while (f->f_pos < dir->i_size) {
                offset = f->f_pos & (BFS_BSIZE-1);
                block = dir->iu_sblock + (f->f_pos >> BFS_BSIZE_BITS);
                bh = sb_bread(dir->i_sb, block);
                if (!bh) {
                        f->f_pos += BFS_BSIZE - offset;
                        continue;
                }
                do {
                        de = (struct bfs_dirent *)(bh->b_data + offset);
                        if (de->ino) {
                                int size = strnlen(de->name, BFS_NAMELEN);
                                if (filldir(dirent, de->name, size, f->f_pos, de->ino, DT_UNKNOWN) < 0) {
                                        brelse(bh);
                                        return 0;
                                }
                        }
                        offset += BFS_DIRENT_SIZE;
                        f->f_pos += BFS_DIRENT_SIZE;
                } while (offset < BFS_BSIZE && f->f_pos < dir->i_size);
                brelse(bh);
        }
 
        UPDATE_ATIME(dir);
        return 0;
}
 
struct file_operations bfs_dir_operations = {
        read:           generic_read_dir,
        readdir:        bfs_readdir,
        fsync:          file_fsync,
};
 
extern void dump_imap(const char *, struct super_block *);
 
static int bfs_create(struct inode * dir, struct dentry * dentry, int mode)
{
        int err;
        struct inode * inode;
        struct super_block * s = dir->i_sb;
        unsigned long ino;
 
        inode = new_inode(s);
        if (!inode)
                return -ENOSPC;
        ino = find_first_zero_bit(s->su_imap, s->su_lasti);
        if (ino > s->su_lasti) {
                iput(inode);
                return -ENOSPC;
        }
        set_bit(ino, s->su_imap);
        s->su_freei--;
        inode->i_uid = current->fsuid;
        inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
        inode->i_blocks = inode->i_blksize = 0;
        inode->i_op = &bfs_file_inops;
        inode->i_fop = &bfs_file_operations;
        inode->i_mapping->a_ops = &bfs_aops;
        inode->i_mode = mode;
        inode->i_ino = inode->iu_dsk_ino = ino;
        inode->iu_sblock = inode->iu_eblock = 0;
        insert_inode_hash(inode);
        mark_inode_dirty(inode);
        dump_imap("create",s);
 
        err = bfs_add_entry(dir, dentry->d_name.name, dentry->d_name.len, inode->i_ino);
        if (err) {
                inode->i_nlink--;
                mark_inode_dirty(inode);
                iput(inode);
                return err;
        }
        d_instantiate(dentry, inode);
        return 0;
}
 
static struct dentry * bfs_lookup(struct inode * dir, struct dentry * dentry)
{
        struct inode * inode = NULL;
        struct buffer_head * bh;
        struct bfs_dirent * de;
 
        if (dentry->d_name.len > BFS_NAMELEN)
                return ERR_PTR(-ENAMETOOLONG);
 
        bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);
        if (bh) {
                unsigned long ino = le32_to_cpu(de->ino);
                brelse(bh);
                inode = iget(dir->i_sb, ino);
                if (!inode)
                        return ERR_PTR(-EACCES);
        }
        d_add(dentry, inode);
        return NULL;
}
 
static int bfs_link(struct dentry * old, struct inode * dir, struct dentry * new)
{
        struct inode * inode = old->d_inode;
        int err;
 
        if (S_ISDIR(inode->i_mode))
                return -EPERM;
 
        err = bfs_add_entry(dir, new->d_name.name, new->d_name.len, inode->i_ino);
        if (err)
                return err;
        inode->i_nlink++;
        inode->i_ctime = CURRENT_TIME;
        mark_inode_dirty(inode);
        atomic_inc(&inode->i_count);
        d_instantiate(new, inode);
        return 0;
}
 
 
static int bfs_unlink(struct inode * dir, struct dentry * dentry)
{
        int error = -ENOENT;
        struct inode * inode;
        struct buffer_head * bh;
        struct bfs_dirent * de;
 
        inode = dentry->d_inode;
        bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);
        if (!bh || de->ino != inode->i_ino)
                goto out_brelse;
 
        if (!inode->i_nlink) {
                printf("unlinking non-existent file %s:%lu (nlink=%d)\n", bdevname(inode->i_dev),
                                inode->i_ino, inode->i_nlink);
                inode->i_nlink = 1;
        }
        de->ino = 0;
        dir->i_version = ++event;
        mark_buffer_dirty(bh);
        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        mark_inode_dirty(dir);
        inode->i_nlink--;
        inode->i_ctime = dir->i_ctime;
        mark_inode_dirty(inode);
        error = 0;
 
out_brelse:
        brelse(bh);
        return error;
}
 
static int bfs_rename(struct inode * old_dir, struct dentry * old_dentry,
                        struct inode * new_dir, struct dentry * new_dentry)
{
        struct inode * old_inode, * new_inode;
        struct buffer_head * old_bh, * new_bh;
        struct bfs_dirent * old_de, * new_de;
        int error = -ENOENT;
 
        old_bh = new_bh = NULL;
        old_inode = old_dentry->d_inode;
        if (S_ISDIR(old_inode->i_mode))
                return -EINVAL;
 
        old_bh = bfs_find_entry(old_dir,
                                old_dentry->d_name.name,
                                old_dentry->d_name.len, &old_de);
 
        if (!old_bh || old_de->ino != old_inode->i_ino)
                goto end_rename;
 
        error = -EPERM;
        new_inode = new_dentry->d_inode;
        new_bh = bfs_find_entry(new_dir,
                                new_dentry->d_name.name,
                                new_dentry->d_name.len, &new_de);
 
        if (new_bh && !new_inode) {
                brelse(new_bh);
                new_bh = NULL;
        }
        if (!new_bh) {
                error = bfs_add_entry(new_dir,
                                        new_dentry->d_name.name,
                                        new_dentry->d_name.len, old_inode->i_ino);
                if (error)
                        goto end_rename;
        }
        old_de->ino = 0;
        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
        old_dir->i_version = ++event;
        mark_inode_dirty(old_dir);
        if (new_inode) {
                new_inode->i_nlink--;
                new_inode->i_ctime = CURRENT_TIME;
                mark_inode_dirty(new_inode);
        }
        mark_buffer_dirty(old_bh);
        error = 0;
 
end_rename:
        brelse(old_bh);
        brelse(new_bh);
        return error;
}
 
struct inode_operations bfs_dir_inops = {
        create:                 bfs_create,
        lookup:                 bfs_lookup,
        link:                   bfs_link,
        unlink:                 bfs_unlink,
        rename:                 bfs_rename,
};
 
static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino)
{
        struct buffer_head * bh;
        struct bfs_dirent * de;
        int block, sblock, eblock, off;
        int i;
 
        dprintf("name=%s, namelen=%d\n", name, namelen);
 
        if (!namelen)
                return -ENOENT;
        if (namelen > BFS_NAMELEN)
                return -ENAMETOOLONG;
 
        sblock = dir->iu_sblock;
        eblock = dir->iu_eblock;
        for (block=sblock; block<=eblock; block++) {
                bh = sb_bread(dir->i_sb, block);
                if(!bh)
                        return -ENOSPC;
                for (off=0; off<BFS_BSIZE; off+=BFS_DIRENT_SIZE) {
                        de = (struct bfs_dirent *)(bh->b_data + off);
                        if (!de->ino) {
                                if ((block-sblock)*BFS_BSIZE + off >= dir->i_size) {
                                        dir->i_size += BFS_DIRENT_SIZE;
                                        dir->i_ctime = CURRENT_TIME;
                                }
                                dir->i_mtime = CURRENT_TIME;
                                mark_inode_dirty(dir);
                                dir->i_version = ++event;
                                de->ino = ino;
                                for (i=0; i<BFS_NAMELEN; i++)
                                        de->name[i] = (i < namelen) ? name[i] : 0;
                                mark_buffer_dirty(bh);
                                brelse(bh);
                                return 0;
                        }
                }
                brelse(bh);
        }
        return -ENOSPC;
}
 
static inline int bfs_namecmp(int len, const char * name, const char * buffer)
{
        if (len < BFS_NAMELEN && buffer[len])
                return 0;
        return !memcmp(name, buffer, len);
}
 
static struct buffer_head * bfs_find_entry(struct inode * dir,
        const char * name, int namelen, struct bfs_dirent ** res_dir)
{
        unsigned long block, offset;
        struct buffer_head * bh;
        struct bfs_dirent * de;
 
        *res_dir = NULL;
        if (namelen > BFS_NAMELEN)
                return NULL;
        bh = NULL;
        block = offset = 0;
        while (block * BFS_BSIZE + offset < dir->i_size) {
                if (!bh) {
                        bh = sb_bread(dir->i_sb, dir->iu_sblock + block);
                        if (!bh) {
                                block++;
                                continue;
                        }
                }
                de = (struct bfs_dirent *)(bh->b_data + offset);
                offset += BFS_DIRENT_SIZE;
                if (de->ino && bfs_namecmp(namelen, name, de->name)) {
                        *res_dir = de;
                        return bh;
                }
                if (offset < bh->b_size)
                        continue;
                brelse(bh);
                bh = NULL;
                offset = 0;
                block++;
        }
        brelse(bh);
        return NULL;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [bfs/] [dir.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* fs/bfs/dir.c`
3			`* BFS directory operations.`
4			`* Copyright (C) 1999,2000 Tigran Aivazian <tigran@veritas.com>`
5			`*/`
6
7			`#include <linux/sched.h>`
8			`#include <linux/string.h>`
9			`#include <linux/bfs_fs.h>`
10			`#include <linux/locks.h>`
11
12			`#include "bfs_defs.h"`
13
14			`#undef DEBUG`
15
16			`#ifdef DEBUG`
17			`#define dprintf(x...) printf(x)`
18			`#else`
19			`#define dprintf(x...)`
20			`#endif`
21
22			`static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino);`
23			`static struct buffer_head * bfs_find_entry(struct inode * dir,`
24			`const char * name, int namelen, struct bfs_dirent ** res_dir);`
25
26			`static int bfs_readdir(struct file * f, void * dirent, filldir_t filldir)`
27			`{`
28			`struct inode * dir = f->f_dentry->d_inode;`
29			`struct buffer_head * bh;`
30			`struct bfs_dirent * de;`
31			`kdev_t dev = dir->i_dev;`
32			`unsigned int offset;`
33			`int block;`
34
35			`if (f->f_pos & (BFS_DIRENT_SIZE-1)) {`
36			`printf("Bad f_pos=%08lx for %s:%08lx\n", (unsigned long)f->f_pos,`
37			`bdevname(dev), dir->i_ino);`
38			`return -EBADF;`
39			`}`
40
41			`while (f->f_pos < dir->i_size) {`
42			`offset = f->f_pos & (BFS_BSIZE-1);`
43			`block = dir->iu_sblock + (f->f_pos >> BFS_BSIZE_BITS);`
44			`bh = sb_bread(dir->i_sb, block);`
45			`if (!bh) {`
46			`f->f_pos += BFS_BSIZE - offset;`
47			`continue;`
48			`}`
49			`do {`
50			`de = (struct bfs_dirent *)(bh->b_data + offset);`
51			`if (de->ino) {`
52			`int size = strnlen(de->name, BFS_NAMELEN);`
53			`if (filldir(dirent, de->name, size, f->f_pos, de->ino, DT_UNKNOWN) < 0) {`
54			`brelse(bh);`
55			`return 0;`
56			`}`
57			`}`
58			`offset += BFS_DIRENT_SIZE;`
59			`f->f_pos += BFS_DIRENT_SIZE;`
60			`} while (offset < BFS_BSIZE && f->f_pos < dir->i_size);`
61			`brelse(bh);`
62			`}`
63
64			`UPDATE_ATIME(dir);`
65			`return 0;`
66			`}`
67
68			`struct file_operations bfs_dir_operations = {`
69			`read: generic_read_dir,`
70			`readdir: bfs_readdir,`
71			`fsync: file_fsync,`
72			`};`
73
74			`extern void dump_imap(const char , struct super_block );`
75
76			`static int bfs_create(struct inode * dir, struct dentry * dentry, int mode)`
77			`{`
78			`int err;`
79			`struct inode * inode;`
80			`struct super_block * s = dir->i_sb;`
81			`unsigned long ino;`
82
83			`inode = new_inode(s);`
84			`if (!inode)`
85			`return -ENOSPC;`
86			`ino = find_first_zero_bit(s->su_imap, s->su_lasti);`
87			`if (ino > s->su_lasti) {`
88			`iput(inode);`
89			`return -ENOSPC;`
90			`}`
91			`set_bit(ino, s->su_imap);`
92			`s->su_freei--;`
93			`inode->i_uid = current->fsuid;`
94			`inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;`
95			`inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;`
96			`inode->i_blocks = inode->i_blksize = 0;`
97			`inode->i_op = &bfs_file_inops;`
98			`inode->i_fop = &bfs_file_operations;`
99			`inode->i_mapping->a_ops = &bfs_aops;`
100			`inode->i_mode = mode;`
101			`inode->i_ino = inode->iu_dsk_ino = ino;`
102			`inode->iu_sblock = inode->iu_eblock = 0;`
103			`insert_inode_hash(inode);`
104			`mark_inode_dirty(inode);`
105			`dump_imap("create",s);`
106
107			`err = bfs_add_entry(dir, dentry->d_name.name, dentry->d_name.len, inode->i_ino);`
108			`if (err) {`
109			`inode->i_nlink--;`
110			`mark_inode_dirty(inode);`
111			`iput(inode);`
112			`return err;`
113			`}`
114			`d_instantiate(dentry, inode);`
115			`return 0;`
116			`}`
117
118			`static struct dentry * bfs_lookup(struct inode * dir, struct dentry * dentry)`
119			`{`
120			`struct inode * inode = NULL;`
121			`struct buffer_head * bh;`
122			`struct bfs_dirent * de;`
123
124			`if (dentry->d_name.len > BFS_NAMELEN)`
125			`return ERR_PTR(-ENAMETOOLONG);`
126
127			`bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);`
128			`if (bh) {`
129			`unsigned long ino = le32_to_cpu(de->ino);`
130			`brelse(bh);`
131			`inode = iget(dir->i_sb, ino);`
132			`if (!inode)`
133			`return ERR_PTR(-EACCES);`
134			`}`
135			`d_add(dentry, inode);`
136			`return NULL;`
137			`}`
138
139			`static int bfs_link(struct dentry * old, struct inode * dir, struct dentry * new)`
140			`{`
141			`struct inode * inode = old->d_inode;`
142			`int err;`
143
144			`if (S_ISDIR(inode->i_mode))`
145			`return -EPERM;`
146
147			`err = bfs_add_entry(dir, new->d_name.name, new->d_name.len, inode->i_ino);`
148			`if (err)`
149			`return err;`
150			`inode->i_nlink++;`
151			`inode->i_ctime = CURRENT_TIME;`
152			`mark_inode_dirty(inode);`
153			`atomic_inc(&inode->i_count);`
154			`d_instantiate(new, inode);`
155			`return 0;`
156			`}`
157
158
159			`static int bfs_unlink(struct inode * dir, struct dentry * dentry)`
160			`{`
161			`int error = -ENOENT;`
162			`struct inode * inode;`
163			`struct buffer_head * bh;`
164			`struct bfs_dirent * de;`
165
166			`inode = dentry->d_inode;`
167			`bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);`
168			`if (!bh \|\| de->ino != inode->i_ino)`
169			`goto out_brelse;`
170
171			`if (!inode->i_nlink) {`
172			`printf("unlinking non-existent file %s:%lu (nlink=%d)\n", bdevname(inode->i_dev),`
173			`inode->i_ino, inode->i_nlink);`
174			`inode->i_nlink = 1;`
175			`}`
176			`de->ino = 0;`
177			`dir->i_version = ++event;`
178			`mark_buffer_dirty(bh);`
179			`dir->i_ctime = dir->i_mtime = CURRENT_TIME;`
180			`mark_inode_dirty(dir);`
181			`inode->i_nlink--;`
182			`inode->i_ctime = dir->i_ctime;`
183			`mark_inode_dirty(inode);`
184			`error = 0;`
185
186			`out_brelse:`
187			`brelse(bh);`
188			`return error;`
189			`}`
190
191			`static int bfs_rename(struct inode * old_dir, struct dentry * old_dentry,`
192			`struct inode * new_dir, struct dentry * new_dentry)`
193			`{`
194			`struct inode * old_inode, * new_inode;`
195			`struct buffer_head * old_bh, * new_bh;`
196			`struct bfs_dirent * old_de, * new_de;`
197			`int error = -ENOENT;`
198
199			`old_bh = new_bh = NULL;`
200			`old_inode = old_dentry->d_inode;`
201			`if (S_ISDIR(old_inode->i_mode))`
202			`return -EINVAL;`
203
204			`old_bh = bfs_find_entry(old_dir,`
205			`old_dentry->d_name.name,`
206			`old_dentry->d_name.len, &old_de);`
207
208			`if (!old_bh \|\| old_de->ino != old_inode->i_ino)`
209			`goto end_rename;`
210
211			`error = -EPERM;`
212			`new_inode = new_dentry->d_inode;`
213			`new_bh = bfs_find_entry(new_dir,`
214			`new_dentry->d_name.name,`
215			`new_dentry->d_name.len, &new_de);`
216
217			`if (new_bh && !new_inode) {`
218			`brelse(new_bh);`
219			`new_bh = NULL;`
220			`}`
221			`if (!new_bh) {`
222			`error = bfs_add_entry(new_dir,`
223			`new_dentry->d_name.name,`
224			`new_dentry->d_name.len, old_inode->i_ino);`
225			`if (error)`
226			`goto end_rename;`
227			`}`
228			`old_de->ino = 0;`
229			`old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;`
230			`old_dir->i_version = ++event;`
231			`mark_inode_dirty(old_dir);`
232			`if (new_inode) {`
233			`new_inode->i_nlink--;`
234			`new_inode->i_ctime = CURRENT_TIME;`
235			`mark_inode_dirty(new_inode);`
236			`}`
237			`mark_buffer_dirty(old_bh);`
238			`error = 0;`
239
240			`end_rename:`
241			`brelse(old_bh);`
242			`brelse(new_bh);`
243			`return error;`
244			`}`
245
246			`struct inode_operations bfs_dir_inops = {`
247			`create: bfs_create,`
248			`lookup: bfs_lookup,`
249			`link: bfs_link,`
250			`unlink: bfs_unlink,`
251			`rename: bfs_rename,`
252			`};`
253
254			`static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino)`
255			`{`
256			`struct buffer_head * bh;`
257			`struct bfs_dirent * de;`
258			`int block, sblock, eblock, off;`
259			`int i;`
260
261			`dprintf("name=%s, namelen=%d\n", name, namelen);`
262
263			`if (!namelen)`
264			`return -ENOENT;`
265			`if (namelen > BFS_NAMELEN)`
266			`return -ENAMETOOLONG;`
267
268			`sblock = dir->iu_sblock;`
269			`eblock = dir->iu_eblock;`
270			`for (block=sblock; block<=eblock; block++) {`
271			`bh = sb_bread(dir->i_sb, block);`
272			`if(!bh)`
273			`return -ENOSPC;`
274			`for (off=0; off<BFS_BSIZE; off+=BFS_DIRENT_SIZE) {`
275			`de = (struct bfs_dirent *)(bh->b_data + off);`
276			`if (!de->ino) {`
277			`if ((block-sblock)*BFS_BSIZE + off >= dir->i_size) {`
278			`dir->i_size += BFS_DIRENT_SIZE;`
279			`dir->i_ctime = CURRENT_TIME;`
280			`}`
281			`dir->i_mtime = CURRENT_TIME;`
282			`mark_inode_dirty(dir);`
283			`dir->i_version = ++event;`
284			`de->ino = ino;`
285			`for (i=0; i<BFS_NAMELEN; i++)`
286			`de->name[i] = (i < namelen) ? name[i] : 0;`
287			`mark_buffer_dirty(bh);`
288			`brelse(bh);`
289			`return 0;`
290			`}`
291			`}`
292			`brelse(bh);`
293			`}`
294			`return -ENOSPC;`
295			`}`
296
297			`static inline int bfs_namecmp(int len, const char * name, const char * buffer)`
298			`{`
299			`if (len < BFS_NAMELEN && buffer[len])`
300			`return 0;`
301			`return !memcmp(name, buffer, len);`
302			`}`
303
304			`static struct buffer_head * bfs_find_entry(struct inode * dir,`
305			`const char * name, int namelen, struct bfs_dirent ** res_dir)`
306			`{`
307			`unsigned long block, offset;`
308			`struct buffer_head * bh;`
309			`struct bfs_dirent * de;`
310
311			`*res_dir = NULL;`
312			`if (namelen > BFS_NAMELEN)`
313			`return NULL;`
314			`bh = NULL;`
315			`block = offset = 0;`
316			`while (block * BFS_BSIZE + offset < dir->i_size) {`
317			`if (!bh) {`
318			`bh = sb_bread(dir->i_sb, dir->iu_sblock + block);`
319			`if (!bh) {`
320			`block++;`
321			`continue;`
322			`}`
323			`}`
324			`de = (struct bfs_dirent *)(bh->b_data + offset);`
325			`offset += BFS_DIRENT_SIZE;`
326			`if (de->ino && bfs_namecmp(namelen, name, de->name)) {`
327			`*res_dir = de;`
328			`return bh;`
329			`}`
330			`if (offset < bh->b_size)`
331			`continue;`
332			`brelse(bh);`
333			`bh = NULL;`
334			`offset = 0;`
335			`block++;`
336			`}`
337			`brelse(bh);`
338			`return NULL;`
339			`}`