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

TOMOYO Linux Cross Reference
Linux/fs/qnx4/inode.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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  * QNX4 file system, Linux implementation.
  3  *
  4  * Version : 0.2.1
  5  *
  6  * Using parts of the xiafs filesystem.
  7  *
  8  * History :
  9  *
 10  * 01-06-1998 by Richard Frowijn : first release.
 11  * 20-06-1998 by Frank Denis : Linux 2.1.99+ support, boot signature, misc.
 12  * 30-06-1998 by Frank Denis : first step to write inodes.
 13  */
 14 
 15 #include <linux/module.h>
 16 #include <linux/init.h>
 17 #include <linux/slab.h>
 18 #include <linux/highuid.h>
 19 #include <linux/smp_lock.h>
 20 #include <linux/pagemap.h>
 21 #include <linux/buffer_head.h>
 22 #include <linux/writeback.h>
 23 #include <linux/statfs.h>
 24 #include "qnx4.h"
 25 
 26 #define QNX4_VERSION  4
 27 #define QNX4_BMNAME   ".bitmap"
 28 
 29 static const struct super_operations qnx4_sops;
 30 
 31 static void qnx4_put_super(struct super_block *sb);
 32 static struct inode *qnx4_alloc_inode(struct super_block *sb);
 33 static void qnx4_destroy_inode(struct inode *inode);
 34 static int qnx4_remount(struct super_block *sb, int *flags, char *data);
 35 static int qnx4_statfs(struct dentry *, struct kstatfs *);
 36 
 37 static const struct super_operations qnx4_sops =
 38 {
 39         .alloc_inode    = qnx4_alloc_inode,
 40         .destroy_inode  = qnx4_destroy_inode,
 41         .put_super      = qnx4_put_super,
 42         .statfs         = qnx4_statfs,
 43         .remount_fs     = qnx4_remount,
 44 };
 45 
 46 static int qnx4_remount(struct super_block *sb, int *flags, char *data)
 47 {
 48         struct qnx4_sb_info *qs;
 49 
 50         qs = qnx4_sb(sb);
 51         qs->Version = QNX4_VERSION;
 52         *flags |= MS_RDONLY;
 53         return 0;
 54 }
 55 
 56 static struct buffer_head *qnx4_getblk(struct inode *inode, int nr,
 57                                        int create)
 58 {
 59         struct buffer_head *result = NULL;
 60 
 61         if ( nr >= 0 )
 62                 nr = qnx4_block_map( inode, nr );
 63         if (nr) {
 64                 result = sb_getblk(inode->i_sb, nr);
 65                 return result;
 66         }
 67         if (!create) {
 68                 return NULL;
 69         }
 70 #if 0
 71         tmp = qnx4_new_block(inode->i_sb);
 72         if (!tmp) {
 73                 return NULL;
 74         }
 75         result = sb_getblk(inode->i_sb, tmp);
 76         if (tst) {
 77                 qnx4_free_block(inode->i_sb, tmp);
 78                 brelse(result);
 79                 goto repeat;
 80         }
 81         tst = tmp;
 82 #endif
 83         inode->i_ctime = CURRENT_TIME_SEC;
 84         mark_inode_dirty(inode);
 85         return result;
 86 }
 87 
 88 struct buffer_head *qnx4_bread(struct inode *inode, int block, int create)
 89 {
 90         struct buffer_head *bh;
 91 
 92         bh = qnx4_getblk(inode, block, create);
 93         if (!bh || buffer_uptodate(bh)) {
 94                 return bh;
 95         }
 96         ll_rw_block(READ, 1, &bh);
 97         wait_on_buffer(bh);
 98         if (buffer_uptodate(bh)) {
 99                 return bh;
100         }
101         brelse(bh);
102 
103         return NULL;
104 }
105 
106 static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create )
107 {
108         unsigned long phys;
109 
110         QNX4DEBUG(("qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock));
111 
112         phys = qnx4_block_map( inode, iblock );
113         if ( phys ) {
114                 // logical block is before EOF
115                 map_bh(bh, inode->i_sb, phys);
116         } else if ( create ) {
117                 // to be done.
118         }
119         return 0;
120 }
121 
122 unsigned long qnx4_block_map( struct inode *inode, long iblock )
123 {
124         int ix;
125         long offset, i_xblk;
126         unsigned long block = 0;
127         struct buffer_head *bh = NULL;
128         struct qnx4_xblk *xblk = NULL;
129         struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode);
130         u16 nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts);
131 
132         if ( iblock < le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size) ) {
133                 // iblock is in the first extent. This is easy.
134                 block = le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_blk) + iblock - 1;
135         } else {
136                 // iblock is beyond first extent. We have to follow the extent chain.
137                 i_xblk = le32_to_cpu(qnx4_inode->di_xblk);
138                 offset = iblock - le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size);
139                 ix = 0;
140                 while ( --nxtnt > 0 ) {
141                         if ( ix == 0 ) {
142                                 // read next xtnt block.
143                                 bh = sb_bread(inode->i_sb, i_xblk - 1);
144                                 if ( !bh ) {
145                                         QNX4DEBUG(("qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1));
146                                         return -EIO;
147                                 }
148                                 xblk = (struct qnx4_xblk*)bh->b_data;
149                                 if ( memcmp( xblk->xblk_signature, "IamXblk", 7 ) ) {
150                                         QNX4DEBUG(("qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk));
151                                         return -EIO;
152                                 }
153                         }
154                         if ( offset < le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size) ) {
155                                 // got it!
156                                 block = le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_blk) + offset - 1;
157                                 break;
158                         }
159                         offset -= le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size);
160                         if ( ++ix >= xblk->xblk_num_xtnts ) {
161                                 i_xblk = le32_to_cpu(xblk->xblk_next_xblk);
162                                 ix = 0;
163                                 brelse( bh );
164                                 bh = NULL;
165                         }
166                 }
167                 if ( bh )
168                         brelse( bh );
169         }
170 
171         QNX4DEBUG(("qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block));
172         return block;
173 }
174 
175 static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf)
176 {
177         struct super_block *sb = dentry->d_sb;
178         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
179 
180         lock_kernel();
181 
182         buf->f_type    = sb->s_magic;
183         buf->f_bsize   = sb->s_blocksize;
184         buf->f_blocks  = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8;
185         buf->f_bfree   = qnx4_count_free_blocks(sb);
186         buf->f_bavail  = buf->f_bfree;
187         buf->f_namelen = QNX4_NAME_MAX;
188         buf->f_fsid.val[0] = (u32)id;
189         buf->f_fsid.val[1] = (u32)(id >> 32);
190 
191         unlock_kernel();
192 
193         return 0;
194 }
195 
196 /*
197  * Check the root directory of the filesystem to make sure
198  * it really _is_ a qnx4 filesystem, and to check the size
199  * of the directory entry.
200  */
201 static const char *qnx4_checkroot(struct super_block *sb)
202 {
203         struct buffer_head *bh;
204         struct qnx4_inode_entry *rootdir;
205         int rd, rl;
206         int i, j;
207         int found = 0;
208 
209         if (*(qnx4_sb(sb)->sb->RootDir.di_fname) != '/') {
210                 return "no qnx4 filesystem (no root dir).";
211         } else {
212                 QNX4DEBUG(("QNX4 filesystem found on dev %s.\n", sb->s_id));
213                 rd = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_blk) - 1;
214                 rl = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_size);
215                 for (j = 0; j < rl; j++) {
216                         bh = sb_bread(sb, rd + j);      /* root dir, first block */
217                         if (bh == NULL) {
218                                 return "unable to read root entry.";
219                         }
220                         for (i = 0; i < QNX4_INODES_PER_BLOCK; i++) {
221                                 rootdir = (struct qnx4_inode_entry *) (bh->b_data + i * QNX4_DIR_ENTRY_SIZE);
222                                 if (rootdir->di_fname != NULL) {
223                                         QNX4DEBUG(("Rootdir entry found : [%s]\n", rootdir->di_fname));
224                                         if (!strncmp(rootdir->di_fname, QNX4_BMNAME, sizeof QNX4_BMNAME)) {
225                                                 found = 1;
226                                                 qnx4_sb(sb)->BitMap = kmalloc( sizeof( struct qnx4_inode_entry ), GFP_KERNEL );
227                                                 if (!qnx4_sb(sb)->BitMap) {
228                                                         brelse (bh);
229                                                         return "not enough memory for bitmap inode";
230                                                 }
231                                                 memcpy( qnx4_sb(sb)->BitMap, rootdir, sizeof( struct qnx4_inode_entry ) );      /* keep bitmap inode known */
232                                                 break;
233                                         }
234                                 }
235                         }
236                         brelse(bh);
237                         if (found != 0) {
238                                 break;
239                         }
240                 }
241                 if (found == 0) {
242                         return "bitmap file not found.";
243                 }
244         }
245         return NULL;
246 }
247 
248 static int qnx4_fill_super(struct super_block *s, void *data, int silent)
249 {
250         struct buffer_head *bh;
251         struct inode *root;
252         const char *errmsg;
253         struct qnx4_sb_info *qs;
254         int ret = -EINVAL;
255 
256         qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL);
257         if (!qs)
258                 return -ENOMEM;
259         s->s_fs_info = qs;
260 
261         sb_set_blocksize(s, QNX4_BLOCK_SIZE);
262 
263         /* Check the superblock signature. Since the qnx4 code is
264            dangerous, we should leave as quickly as possible
265            if we don't belong here... */
266         bh = sb_bread(s, 1);
267         if (!bh) {
268                 printk("qnx4: unable to read the superblock\n");
269                 goto outnobh;
270         }
271         if ( le32_to_cpup((__le32*) bh->b_data) != QNX4_SUPER_MAGIC ) {
272                 if (!silent)
273                         printk("qnx4: wrong fsid in superblock.\n");
274                 goto out;
275         }
276         s->s_op = &qnx4_sops;
277         s->s_magic = QNX4_SUPER_MAGIC;
278         s->s_flags |= MS_RDONLY;        /* Yup, read-only yet */
279         qnx4_sb(s)->sb_buf = bh;
280         qnx4_sb(s)->sb = (struct qnx4_super_block *) bh->b_data;
281 
282 
283         /* check before allocating dentries, inodes, .. */
284         errmsg = qnx4_checkroot(s);
285         if (errmsg != NULL) {
286                 if (!silent)
287                         printk("qnx4: %s\n", errmsg);
288                 goto out;
289         }
290 
291         /* does root not have inode number QNX4_ROOT_INO ?? */
292         root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK);
293         if (IS_ERR(root)) {
294                 printk("qnx4: get inode failed\n");
295                 ret = PTR_ERR(root);
296                 goto out;
297         }
298 
299         ret = -ENOMEM;
300         s->s_root = d_alloc_root(root);
301         if (s->s_root == NULL)
302                 goto outi;
303 
304         brelse(bh);
305 
306         return 0;
307 
308       outi:
309         iput(root);
310       out:
311         brelse(bh);
312       outnobh:
313         kfree(qs);
314         s->s_fs_info = NULL;
315         return ret;
316 }
317 
318 static void qnx4_put_super(struct super_block *sb)
319 {
320         struct qnx4_sb_info *qs = qnx4_sb(sb);
321         kfree( qs->BitMap );
322         kfree( qs );
323         sb->s_fs_info = NULL;
324         return;
325 }
326 
327 static int qnx4_writepage(struct page *page, struct writeback_control *wbc)
328 {
329         return block_write_full_page(page,qnx4_get_block, wbc);
330 }
331 
332 static int qnx4_readpage(struct file *file, struct page *page)
333 {
334         return block_read_full_page(page,qnx4_get_block);
335 }
336 
337 static int qnx4_write_begin(struct file *file, struct address_space *mapping,
338                         loff_t pos, unsigned len, unsigned flags,
339                         struct page **pagep, void **fsdata)
340 {
341         struct qnx4_inode_info *qnx4_inode = qnx4_i(mapping->host);
342         *pagep = NULL;
343         return cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
344                                 qnx4_get_block,
345                                 &qnx4_inode->mmu_private);
346 }
347 static sector_t qnx4_bmap(struct address_space *mapping, sector_t block)
348 {
349         return generic_block_bmap(mapping,block,qnx4_get_block);
350 }
351 static const struct address_space_operations qnx4_aops = {
352         .readpage       = qnx4_readpage,
353         .writepage      = qnx4_writepage,
354         .sync_page      = block_sync_page,
355         .write_begin    = qnx4_write_begin,
356         .write_end      = generic_write_end,
357         .bmap           = qnx4_bmap
358 };
359 
360 struct inode *qnx4_iget(struct super_block *sb, unsigned long ino)
361 {
362         struct buffer_head *bh;
363         struct qnx4_inode_entry *raw_inode;
364         int block;
365         struct qnx4_inode_entry *qnx4_inode;
366         struct inode *inode;
367 
368         inode = iget_locked(sb, ino);
369         if (!inode)
370                 return ERR_PTR(-ENOMEM);
371         if (!(inode->i_state & I_NEW))
372                 return inode;
373 
374         qnx4_inode = qnx4_raw_inode(inode);
375         inode->i_mode = 0;
376 
377         QNX4DEBUG(("Reading inode : [%d]\n", ino));
378         if (!ino) {
379                 printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is "
380                                 "out of range\n",
381                        sb->s_id, ino);
382                 iget_failed(inode);
383                 return ERR_PTR(-EIO);
384         }
385         block = ino / QNX4_INODES_PER_BLOCK;
386 
387         if (!(bh = sb_bread(sb, block))) {
388                 printk("qnx4: major problem: unable to read inode from dev "
389                        "%s\n", sb->s_id);
390                 iget_failed(inode);
391                 return ERR_PTR(-EIO);
392         }
393         raw_inode = ((struct qnx4_inode_entry *) bh->b_data) +
394             (ino % QNX4_INODES_PER_BLOCK);
395 
396         inode->i_mode    = le16_to_cpu(raw_inode->di_mode);
397         inode->i_uid     = (uid_t)le16_to_cpu(raw_inode->di_uid);
398         inode->i_gid     = (gid_t)le16_to_cpu(raw_inode->di_gid);
399         inode->i_nlink   = le16_to_cpu(raw_inode->di_nlink);
400         inode->i_size    = le32_to_cpu(raw_inode->di_size);
401         inode->i_mtime.tv_sec   = le32_to_cpu(raw_inode->di_mtime);
402         inode->i_mtime.tv_nsec = 0;
403         inode->i_atime.tv_sec   = le32_to_cpu(raw_inode->di_atime);
404         inode->i_atime.tv_nsec = 0;
405         inode->i_ctime.tv_sec   = le32_to_cpu(raw_inode->di_ctime);
406         inode->i_ctime.tv_nsec = 0;
407         inode->i_blocks  = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size);
408 
409         memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE);
410         if (S_ISREG(inode->i_mode)) {
411                 inode->i_fop = &generic_ro_fops;
412                 inode->i_mapping->a_ops = &qnx4_aops;
413                 qnx4_i(inode)->mmu_private = inode->i_size;
414         } else if (S_ISDIR(inode->i_mode)) {
415                 inode->i_op = &qnx4_dir_inode_operations;
416                 inode->i_fop = &qnx4_dir_operations;
417         } else if (S_ISLNK(inode->i_mode)) {
418                 inode->i_op = &page_symlink_inode_operations;
419                 inode->i_mapping->a_ops = &qnx4_aops;
420                 qnx4_i(inode)->mmu_private = inode->i_size;
421         } else {
422                 printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n",
423                         ino, sb->s_id);
424                 iget_failed(inode);
425                 brelse(bh);
426                 return ERR_PTR(-EIO);
427         }
428         brelse(bh);
429         unlock_new_inode(inode);
430         return inode;
431 }
432 
433 static struct kmem_cache *qnx4_inode_cachep;
434 
435 static struct inode *qnx4_alloc_inode(struct super_block *sb)
436 {
437         struct qnx4_inode_info *ei;
438         ei = kmem_cache_alloc(qnx4_inode_cachep, GFP_KERNEL);
439         if (!ei)
440                 return NULL;
441         return &ei->vfs_inode;
442 }
443 
444 static void qnx4_destroy_inode(struct inode *inode)
445 {
446         kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode));
447 }
448 
449 static void init_once(void *foo)
450 {
451         struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo;
452 
453         inode_init_once(&ei->vfs_inode);
454 }
455 
456 static int init_inodecache(void)
457 {
458         qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache",
459                                              sizeof(struct qnx4_inode_info),
460                                              0, (SLAB_RECLAIM_ACCOUNT|
461                                                 SLAB_MEM_SPREAD),
462                                              init_once);
463         if (qnx4_inode_cachep == NULL)
464                 return -ENOMEM;
465         return 0;
466 }
467 
468 static void destroy_inodecache(void)
469 {
470         kmem_cache_destroy(qnx4_inode_cachep);
471 }
472 
473 static int qnx4_get_sb(struct file_system_type *fs_type,
474         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
475 {
476         return get_sb_bdev(fs_type, flags, dev_name, data, qnx4_fill_super,
477                            mnt);
478 }
479 
480 static struct file_system_type qnx4_fs_type = {
481         .owner          = THIS_MODULE,
482         .name           = "qnx4",
483         .get_sb         = qnx4_get_sb,
484         .kill_sb        = kill_block_super,
485         .fs_flags       = FS_REQUIRES_DEV,
486 };
487 
488 static int __init init_qnx4_fs(void)
489 {
490         int err;
491 
492         err = init_inodecache();
493         if (err)
494                 return err;
495 
496         err = register_filesystem(&qnx4_fs_type);
497         if (err) {
498                 destroy_inodecache();
499                 return err;
500         }
501 
502         printk("QNX4 filesystem 0.2.3 registered.\n");
503         return 0;
504 }
505 
506 static void __exit exit_qnx4_fs(void)
507 {
508         unregister_filesystem(&qnx4_fs_type);
509         destroy_inodecache();
510 }
511 
512 module_init(init_qnx4_fs)
513 module_exit(exit_qnx4_fs)
514 MODULE_LICENSE("GPL");
515 
516 

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