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

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

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ 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.69 ] ~ [ 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.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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/minix/dir.c
  3  *
  4  *  Copyright (C) 1991, 1992 Linus Torvalds
  5  *
  6  *  minix directory handling functions
  7  *
  8  *  Updated to filesystem version 3 by Daniel Aragones
  9  */
 10 
 11 #include "minix.h"
 12 #include <linux/buffer_head.h>
 13 #include <linux/highmem.h>
 14 #include <linux/swap.h>
 15 
 16 typedef struct minix_dir_entry minix_dirent;
 17 typedef struct minix3_dir_entry minix3_dirent;
 18 
 19 static int minix_readdir(struct file *, struct dir_context *);
 20 
 21 const struct file_operations minix_dir_operations = {
 22         .llseek         = generic_file_llseek,
 23         .read           = generic_read_dir,
 24         .iterate        = minix_readdir,
 25         .fsync          = generic_file_fsync,
 26 };
 27 
 28 static inline void dir_put_page(struct page *page)
 29 {
 30         kunmap(page);
 31         page_cache_release(page);
 32 }
 33 
 34 /*
 35  * Return the offset into page `page_nr' of the last valid
 36  * byte in that page, plus one.
 37  */
 38 static unsigned
 39 minix_last_byte(struct inode *inode, unsigned long page_nr)
 40 {
 41         unsigned last_byte = PAGE_CACHE_SIZE;
 42 
 43         if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT))
 44                 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1);
 45         return last_byte;
 46 }
 47 
 48 static inline unsigned long dir_pages(struct inode *inode)
 49 {
 50         return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
 51 }
 52 
 53 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
 54 {
 55         struct address_space *mapping = page->mapping;
 56         struct inode *dir = mapping->host;
 57         int err = 0;
 58         block_write_end(NULL, mapping, pos, len, len, page, NULL);
 59 
 60         if (pos+len > dir->i_size) {
 61                 i_size_write(dir, pos+len);
 62                 mark_inode_dirty(dir);
 63         }
 64         if (IS_DIRSYNC(dir))
 65                 err = write_one_page(page, 1);
 66         else
 67                 unlock_page(page);
 68         return err;
 69 }
 70 
 71 static struct page * dir_get_page(struct inode *dir, unsigned long n)
 72 {
 73         struct address_space *mapping = dir->i_mapping;
 74         struct page *page = read_mapping_page(mapping, n, NULL);
 75         if (!IS_ERR(page))
 76                 kmap(page);
 77         return page;
 78 }
 79 
 80 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
 81 {
 82         return (void*)((char*)de + sbi->s_dirsize);
 83 }
 84 
 85 static int minix_readdir(struct file *file, struct dir_context *ctx)
 86 {
 87         struct inode *inode = file_inode(file);
 88         struct super_block *sb = inode->i_sb;
 89         struct minix_sb_info *sbi = minix_sb(sb);
 90         unsigned chunk_size = sbi->s_dirsize;
 91         unsigned long npages = dir_pages(inode);
 92         unsigned long pos = ctx->pos;
 93         unsigned offset;
 94         unsigned long n;
 95 
 96         ctx->pos = pos = ALIGN(pos, chunk_size);
 97         if (pos >= inode->i_size)
 98                 return 0;
 99 
100         offset = pos & ~PAGE_CACHE_MASK;
101         n = pos >> PAGE_CACHE_SHIFT;
102 
103         for ( ; n < npages; n++, offset = 0) {
104                 char *p, *kaddr, *limit;
105                 struct page *page = dir_get_page(inode, n);
106 
107                 if (IS_ERR(page))
108                         continue;
109                 kaddr = (char *)page_address(page);
110                 p = kaddr+offset;
111                 limit = kaddr + minix_last_byte(inode, n) - chunk_size;
112                 for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
113                         const char *name;
114                         __u32 inumber;
115                         if (sbi->s_version == MINIX_V3) {
116                                 minix3_dirent *de3 = (minix3_dirent *)p;
117                                 name = de3->name;
118                                 inumber = de3->inode;
119                         } else {
120                                 minix_dirent *de = (minix_dirent *)p;
121                                 name = de->name;
122                                 inumber = de->inode;
123                         }
124                         if (inumber) {
125                                 unsigned l = strnlen(name, sbi->s_namelen);
126                                 if (!dir_emit(ctx, name, l,
127                                               inumber, DT_UNKNOWN)) {
128                                         dir_put_page(page);
129                                         return 0;
130                                 }
131                         }
132                         ctx->pos += chunk_size;
133                 }
134                 dir_put_page(page);
135         }
136         return 0;
137 }
138 
139 static inline int namecompare(int len, int maxlen,
140         const char * name, const char * buffer)
141 {
142         if (len < maxlen && buffer[len])
143                 return 0;
144         return !memcmp(name, buffer, len);
145 }
146 
147 /*
148  *      minix_find_entry()
149  *
150  * finds an entry in the specified directory with the wanted name. It
151  * returns the cache buffer in which the entry was found, and the entry
152  * itself (as a parameter - res_dir). It does NOT read the inode of the
153  * entry - you'll have to do that yourself if you want to.
154  */
155 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
156 {
157         const char * name = dentry->d_name.name;
158         int namelen = dentry->d_name.len;
159         struct inode * dir = d_inode(dentry->d_parent);
160         struct super_block * sb = dir->i_sb;
161         struct minix_sb_info * sbi = minix_sb(sb);
162         unsigned long n;
163         unsigned long npages = dir_pages(dir);
164         struct page *page = NULL;
165         char *p;
166 
167         char *namx;
168         __u32 inumber;
169         *res_page = NULL;
170 
171         for (n = 0; n < npages; n++) {
172                 char *kaddr, *limit;
173 
174                 page = dir_get_page(dir, n);
175                 if (IS_ERR(page))
176                         continue;
177 
178                 kaddr = (char*)page_address(page);
179                 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;
180                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
181                         if (sbi->s_version == MINIX_V3) {
182                                 minix3_dirent *de3 = (minix3_dirent *)p;
183                                 namx = de3->name;
184                                 inumber = de3->inode;
185                         } else {
186                                 minix_dirent *de = (minix_dirent *)p;
187                                 namx = de->name;
188                                 inumber = de->inode;
189                         }
190                         if (!inumber)
191                                 continue;
192                         if (namecompare(namelen, sbi->s_namelen, name, namx))
193                                 goto found;
194                 }
195                 dir_put_page(page);
196         }
197         return NULL;
198 
199 found:
200         *res_page = page;
201         return (minix_dirent *)p;
202 }
203 
204 int minix_add_link(struct dentry *dentry, struct inode *inode)
205 {
206         struct inode *dir = d_inode(dentry->d_parent);
207         const char * name = dentry->d_name.name;
208         int namelen = dentry->d_name.len;
209         struct super_block * sb = dir->i_sb;
210         struct minix_sb_info * sbi = minix_sb(sb);
211         struct page *page = NULL;
212         unsigned long npages = dir_pages(dir);
213         unsigned long n;
214         char *kaddr, *p;
215         minix_dirent *de;
216         minix3_dirent *de3;
217         loff_t pos;
218         int err;
219         char *namx = NULL;
220         __u32 inumber;
221 
222         /*
223          * We take care of directory expansion in the same loop
224          * This code plays outside i_size, so it locks the page
225          * to protect that region.
226          */
227         for (n = 0; n <= npages; n++) {
228                 char *limit, *dir_end;
229 
230                 page = dir_get_page(dir, n);
231                 err = PTR_ERR(page);
232                 if (IS_ERR(page))
233                         goto out;
234                 lock_page(page);
235                 kaddr = (char*)page_address(page);
236                 dir_end = kaddr + minix_last_byte(dir, n);
237                 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize;
238                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
239                         de = (minix_dirent *)p;
240                         de3 = (minix3_dirent *)p;
241                         if (sbi->s_version == MINIX_V3) {
242                                 namx = de3->name;
243                                 inumber = de3->inode;
244                         } else {
245                                 namx = de->name;
246                                 inumber = de->inode;
247                         }
248                         if (p == dir_end) {
249                                 /* We hit i_size */
250                                 if (sbi->s_version == MINIX_V3)
251                                         de3->inode = 0;
252                                 else
253                                         de->inode = 0;
254                                 goto got_it;
255                         }
256                         if (!inumber)
257                                 goto got_it;
258                         err = -EEXIST;
259                         if (namecompare(namelen, sbi->s_namelen, name, namx))
260                                 goto out_unlock;
261                 }
262                 unlock_page(page);
263                 dir_put_page(page);
264         }
265         BUG();
266         return -EINVAL;
267 
268 got_it:
269         pos = page_offset(page) + p - (char *)page_address(page);
270         err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
271         if (err)
272                 goto out_unlock;
273         memcpy (namx, name, namelen);
274         if (sbi->s_version == MINIX_V3) {
275                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4);
276                 de3->inode = inode->i_ino;
277         } else {
278                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2);
279                 de->inode = inode->i_ino;
280         }
281         err = dir_commit_chunk(page, pos, sbi->s_dirsize);
282         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
283         mark_inode_dirty(dir);
284 out_put:
285         dir_put_page(page);
286 out:
287         return err;
288 out_unlock:
289         unlock_page(page);
290         goto out_put;
291 }
292 
293 int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
294 {
295         struct inode *inode = page->mapping->host;
296         char *kaddr = page_address(page);
297         loff_t pos = page_offset(page) + (char*)de - kaddr;
298         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
299         unsigned len = sbi->s_dirsize;
300         int err;
301 
302         lock_page(page);
303         err = minix_prepare_chunk(page, pos, len);
304         if (err == 0) {
305                 if (sbi->s_version == MINIX_V3)
306                         ((minix3_dirent *) de)->inode = 0;
307                 else
308                         de->inode = 0;
309                 err = dir_commit_chunk(page, pos, len);
310         } else {
311                 unlock_page(page);
312         }
313         dir_put_page(page);
314         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
315         mark_inode_dirty(inode);
316         return err;
317 }
318 
319 int minix_make_empty(struct inode *inode, struct inode *dir)
320 {
321         struct page *page = grab_cache_page(inode->i_mapping, 0);
322         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
323         char *kaddr;
324         int err;
325 
326         if (!page)
327                 return -ENOMEM;
328         err = minix_prepare_chunk(page, 0, 2 * sbi->s_dirsize);
329         if (err) {
330                 unlock_page(page);
331                 goto fail;
332         }
333 
334         kaddr = kmap_atomic(page);
335         memset(kaddr, 0, PAGE_CACHE_SIZE);
336 
337         if (sbi->s_version == MINIX_V3) {
338                 minix3_dirent *de3 = (minix3_dirent *)kaddr;
339 
340                 de3->inode = inode->i_ino;
341                 strcpy(de3->name, ".");
342                 de3 = minix_next_entry(de3, sbi);
343                 de3->inode = dir->i_ino;
344                 strcpy(de3->name, "..");
345         } else {
346                 minix_dirent *de = (minix_dirent *)kaddr;
347 
348                 de->inode = inode->i_ino;
349                 strcpy(de->name, ".");
350                 de = minix_next_entry(de, sbi);
351                 de->inode = dir->i_ino;
352                 strcpy(de->name, "..");
353         }
354         kunmap_atomic(kaddr);
355 
356         err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
357 fail:
358         page_cache_release(page);
359         return err;
360 }
361 
362 /*
363  * routine to check that the specified directory is empty (for rmdir)
364  */
365 int minix_empty_dir(struct inode * inode)
366 {
367         struct page *page = NULL;
368         unsigned long i, npages = dir_pages(inode);
369         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
370         char *name;
371         __u32 inumber;
372 
373         for (i = 0; i < npages; i++) {
374                 char *p, *kaddr, *limit;
375 
376                 page = dir_get_page(inode, i);
377                 if (IS_ERR(page))
378                         continue;
379 
380                 kaddr = (char *)page_address(page);
381                 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;
382                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
383                         if (sbi->s_version == MINIX_V3) {
384                                 minix3_dirent *de3 = (minix3_dirent *)p;
385                                 name = de3->name;
386                                 inumber = de3->inode;
387                         } else {
388                                 minix_dirent *de = (minix_dirent *)p;
389                                 name = de->name;
390                                 inumber = de->inode;
391                         }
392 
393                         if (inumber != 0) {
394                                 /* check for . and .. */
395                                 if (name[0] != '.')
396                                         goto not_empty;
397                                 if (!name[1]) {
398                                         if (inumber != inode->i_ino)
399                                                 goto not_empty;
400                                 } else if (name[1] != '.')
401                                         goto not_empty;
402                                 else if (name[2])
403                                         goto not_empty;
404                         }
405                 }
406                 dir_put_page(page);
407         }
408         return 1;
409 
410 not_empty:
411         dir_put_page(page);
412         return 0;
413 }
414 
415 /* Releases the page */
416 void minix_set_link(struct minix_dir_entry *de, struct page *page,
417         struct inode *inode)
418 {
419         struct inode *dir = page->mapping->host;
420         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
421         loff_t pos = page_offset(page) +
422                         (char *)de-(char*)page_address(page);
423         int err;
424 
425         lock_page(page);
426 
427         err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
428         if (err == 0) {
429                 if (sbi->s_version == MINIX_V3)
430                         ((minix3_dirent *) de)->inode = inode->i_ino;
431                 else
432                         de->inode = inode->i_ino;
433                 err = dir_commit_chunk(page, pos, sbi->s_dirsize);
434         } else {
435                 unlock_page(page);
436         }
437         dir_put_page(page);
438         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
439         mark_inode_dirty(dir);
440 }
441 
442 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p)
443 {
444         struct page *page = dir_get_page(dir, 0);
445         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
446         struct minix_dir_entry *de = NULL;
447 
448         if (!IS_ERR(page)) {
449                 de = minix_next_entry(page_address(page), sbi);
450                 *p = page;
451         }
452         return de;
453 }
454 
455 ino_t minix_inode_by_name(struct dentry *dentry)
456 {
457         struct page *page;
458         struct minix_dir_entry *de = minix_find_entry(dentry, &page);
459         ino_t res = 0;
460 
461         if (de) {
462                 struct address_space *mapping = page->mapping;
463                 struct inode *inode = mapping->host;
464                 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
465 
466                 if (sbi->s_version == MINIX_V3)
467                         res = ((minix3_dirent *) de)->inode;
468                 else
469                         res = de->inode;
470                 dir_put_page(page);
471         }
472         return res;
473 }
474 

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