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

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

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

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