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

TOMOYO Linux Cross Reference
Linux/fs/adfs/dir.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ 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.76 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  *  linux/fs/adfs/dir.c
  3  *
  4  *  Copyright (C) 1999-2000 Russell King
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  *
 10  *  Common directory handling for ADFS
 11  */
 12 #include "adfs.h"
 13 
 14 /*
 15  * For future.  This should probably be per-directory.
 16  */
 17 static DEFINE_RWLOCK(adfs_dir_lock);
 18 
 19 static int
 20 adfs_readdir(struct file *file, struct dir_context *ctx)
 21 {
 22         struct inode *inode = file_inode(file);
 23         struct super_block *sb = inode->i_sb;
 24         const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
 25         struct object_info obj;
 26         struct adfs_dir dir;
 27         int ret = 0;
 28 
 29         if (ctx->pos >> 32)
 30                 return 0;
 31 
 32         ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
 33         if (ret)
 34                 return ret;
 35 
 36         if (ctx->pos == 0) {
 37                 if (!dir_emit_dot(file, ctx))
 38                         goto free_out;
 39                 ctx->pos = 1;
 40         }
 41         if (ctx->pos == 1) {
 42                 if (!dir_emit(ctx, "..", 2, dir.parent_id, DT_DIR))
 43                         goto free_out;
 44                 ctx->pos = 2;
 45         }
 46 
 47         read_lock(&adfs_dir_lock);
 48 
 49         ret = ops->setpos(&dir, ctx->pos - 2);
 50         if (ret)
 51                 goto unlock_out;
 52         while (ops->getnext(&dir, &obj) == 0) {
 53                 if (!dir_emit(ctx, obj.name, obj.name_len,
 54                             obj.file_id, DT_UNKNOWN))
 55                         break;
 56                 ctx->pos++;
 57         }
 58 
 59 unlock_out:
 60         read_unlock(&adfs_dir_lock);
 61 
 62 free_out:
 63         ops->free(&dir);
 64         return ret;
 65 }
 66 
 67 int
 68 adfs_dir_update(struct super_block *sb, struct object_info *obj, int wait)
 69 {
 70         int ret = -EINVAL;
 71 #ifdef CONFIG_ADFS_FS_RW
 72         const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
 73         struct adfs_dir dir;
 74 
 75         printk(KERN_INFO "adfs_dir_update: object %06X in dir %06X\n",
 76                  obj->file_id, obj->parent_id);
 77 
 78         if (!ops->update) {
 79                 ret = -EINVAL;
 80                 goto out;
 81         }
 82 
 83         ret = ops->read(sb, obj->parent_id, 0, &dir);
 84         if (ret)
 85                 goto out;
 86 
 87         write_lock(&adfs_dir_lock);
 88         ret = ops->update(&dir, obj);
 89         write_unlock(&adfs_dir_lock);
 90 
 91         if (wait) {
 92                 int err = ops->sync(&dir);
 93                 if (!ret)
 94                         ret = err;
 95         }
 96 
 97         ops->free(&dir);
 98 out:
 99 #endif
100         return ret;
101 }
102 
103 static int
104 adfs_match(struct qstr *name, struct object_info *obj)
105 {
106         int i;
107 
108         if (name->len != obj->name_len)
109                 return 0;
110 
111         for (i = 0; i < name->len; i++) {
112                 char c1, c2;
113 
114                 c1 = name->name[i];
115                 c2 = obj->name[i];
116 
117                 if (c1 >= 'A' && c1 <= 'Z')
118                         c1 += 'a' - 'A';
119                 if (c2 >= 'A' && c2 <= 'Z')
120                         c2 += 'a' - 'A';
121 
122                 if (c1 != c2)
123                         return 0;
124         }
125         return 1;
126 }
127 
128 static int
129 adfs_dir_lookup_byname(struct inode *inode, struct qstr *name, struct object_info *obj)
130 {
131         struct super_block *sb = inode->i_sb;
132         const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
133         struct adfs_dir dir;
134         int ret;
135 
136         ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
137         if (ret)
138                 goto out;
139 
140         if (ADFS_I(inode)->parent_id != dir.parent_id) {
141                 adfs_error(sb, "parent directory changed under me! (%lx but got %x)\n",
142                            ADFS_I(inode)->parent_id, dir.parent_id);
143                 ret = -EIO;
144                 goto free_out;
145         }
146 
147         obj->parent_id = inode->i_ino;
148 
149         /*
150          * '.' is handled by reserved_lookup() in fs/namei.c
151          */
152         if (name->len == 2 && name->name[0] == '.' && name->name[1] == '.') {
153                 /*
154                  * Currently unable to fill in the rest of 'obj',
155                  * but this is better than nothing.  We need to
156                  * ascend one level to find it's parent.
157                  */
158                 obj->name_len = 0;
159                 obj->file_id  = obj->parent_id;
160                 goto free_out;
161         }
162 
163         read_lock(&adfs_dir_lock);
164 
165         ret = ops->setpos(&dir, 0);
166         if (ret)
167                 goto unlock_out;
168 
169         ret = -ENOENT;
170         while (ops->getnext(&dir, obj) == 0) {
171                 if (adfs_match(name, obj)) {
172                         ret = 0;
173                         break;
174                 }
175         }
176 
177 unlock_out:
178         read_unlock(&adfs_dir_lock);
179 
180 free_out:
181         ops->free(&dir);
182 out:
183         return ret;
184 }
185 
186 const struct file_operations adfs_dir_operations = {
187         .read           = generic_read_dir,
188         .llseek         = generic_file_llseek,
189         .iterate        = adfs_readdir,
190         .fsync          = generic_file_fsync,
191 };
192 
193 static int
194 adfs_hash(const struct dentry *parent, struct qstr *qstr)
195 {
196         const unsigned int name_len = ADFS_SB(parent->d_sb)->s_namelen;
197         const unsigned char *name;
198         unsigned long hash;
199         int i;
200 
201         if (qstr->len < name_len)
202                 return 0;
203 
204         /*
205          * Truncate the name in place, avoids
206          * having to define a compare function.
207          */
208         qstr->len = i = name_len;
209         name = qstr->name;
210         hash = init_name_hash();
211         while (i--) {
212                 char c;
213 
214                 c = *name++;
215                 if (c >= 'A' && c <= 'Z')
216                         c += 'a' - 'A';
217 
218                 hash = partial_name_hash(c, hash);
219         }
220         qstr->hash = end_name_hash(hash);
221 
222         return 0;
223 }
224 
225 /*
226  * Compare two names, taking note of the name length
227  * requirements of the underlying filesystem.
228  */
229 static int
230 adfs_compare(const struct dentry *parent, const struct dentry *dentry,
231                 unsigned int len, const char *str, const struct qstr *name)
232 {
233         int i;
234 
235         if (len != name->len)
236                 return 1;
237 
238         for (i = 0; i < name->len; i++) {
239                 char a, b;
240 
241                 a = str[i];
242                 b = name->name[i];
243 
244                 if (a >= 'A' && a <= 'Z')
245                         a += 'a' - 'A';
246                 if (b >= 'A' && b <= 'Z')
247                         b += 'a' - 'A';
248 
249                 if (a != b)
250                         return 1;
251         }
252         return 0;
253 }
254 
255 const struct dentry_operations adfs_dentry_operations = {
256         .d_hash         = adfs_hash,
257         .d_compare      = adfs_compare,
258 };
259 
260 static struct dentry *
261 adfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
262 {
263         struct inode *inode = NULL;
264         struct object_info obj;
265         int error;
266 
267         error = adfs_dir_lookup_byname(dir, &dentry->d_name, &obj);
268         if (error == 0) {
269                 error = -EACCES;
270                 /*
271                  * This only returns NULL if get_empty_inode
272                  * fails.
273                  */
274                 inode = adfs_iget(dir->i_sb, &obj);
275                 if (inode)
276                         error = 0;
277         }
278         d_add(dentry, inode);
279         return ERR_PTR(error);
280 }
281 
282 /*
283  * directories can handle most operations...
284  */
285 const struct inode_operations adfs_dir_inode_operations = {
286         .lookup         = adfs_lookup,
287         .setattr        = adfs_notify_change,
288 };
289 

~ [ 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