super.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663
  1. /* Block- or MTD-based romfs
  2. *
  3. * Copyright © 2007 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. *
  6. * Derived from: ROMFS file system, Linux implementation
  7. *
  8. * Copyright © 1997-1999 Janos Farkas <chexum@shadow.banki.hu>
  9. *
  10. * Using parts of the minix filesystem
  11. * Copyright © 1991, 1992 Linus Torvalds
  12. *
  13. * and parts of the affs filesystem additionally
  14. * Copyright © 1993 Ray Burr
  15. * Copyright © 1996 Hans-Joachim Widmaier
  16. *
  17. * Changes
  18. * Changed for 2.1.19 modules
  19. * Jan 1997 Initial release
  20. * Jun 1997 2.1.43+ changes
  21. * Proper page locking in readpage
  22. * Changed to work with 2.1.45+ fs
  23. * Jul 1997 Fixed follow_link
  24. * 2.1.47
  25. * lookup shouldn't return -ENOENT
  26. * from Horst von Brand:
  27. * fail on wrong checksum
  28. * double unlock_super was possible
  29. * correct namelen for statfs
  30. * spotted by Bill Hawes:
  31. * readlink shouldn't iput()
  32. * Jun 1998 2.1.106 from Avery Pennarun: glibc scandir()
  33. * exposed a problem in readdir
  34. * 2.1.107 code-freeze spellchecker run
  35. * Aug 1998 2.1.118+ VFS changes
  36. * Sep 1998 2.1.122 another VFS change (follow_link)
  37. * Apr 1999 2.2.7 no more EBADF checking in
  38. * lookup/readdir, use ERR_PTR
  39. * Jun 1999 2.3.6 d_alloc_root use changed
  40. * 2.3.9 clean up usage of ENOENT/negative
  41. * dentries in lookup
  42. * clean up page flags setting
  43. * (error, uptodate, locking) in
  44. * in readpage
  45. * use init_special_inode for
  46. * fifos/sockets (and streamline) in
  47. * read_inode, fix _ops table order
  48. * Aug 1999 2.3.16 __initfunc() => __init change
  49. * Oct 1999 2.3.24 page->owner hack obsoleted
  50. * Nov 1999 2.3.27 2.3.25+ page->offset => index change
  51. *
  52. *
  53. * This program is free software; you can redistribute it and/or
  54. * modify it under the terms of the GNU General Public Licence
  55. * as published by the Free Software Foundation; either version
  56. * 2 of the Licence, or (at your option) any later version.
  57. */
  58. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  59. #include <linux/module.h>
  60. #include <linux/string.h>
  61. #include <linux/fs.h>
  62. #include <linux/time.h>
  63. #include <linux/slab.h>
  64. #include <linux/init.h>
  65. #include <linux/blkdev.h>
  66. #include <linux/parser.h>
  67. #include <linux/mount.h>
  68. #include <linux/namei.h>
  69. #include <linux/statfs.h>
  70. #include <linux/mtd/super.h>
  71. #include <linux/ctype.h>
  72. #include <linux/highmem.h>
  73. #include <linux/pagemap.h>
  74. #include <linux/uaccess.h>
  75. #include <linux/major.h>
  76. #include "internal.h"
  77. static struct kmem_cache *romfs_inode_cachep;
  78. static const umode_t romfs_modemap[8] = {
  79. 0, /* hard link */
  80. S_IFDIR | 0644, /* directory */
  81. S_IFREG | 0644, /* regular file */
  82. S_IFLNK | 0777, /* symlink */
  83. S_IFBLK | 0600, /* blockdev */
  84. S_IFCHR | 0600, /* chardev */
  85. S_IFSOCK | 0644, /* socket */
  86. S_IFIFO | 0644 /* FIFO */
  87. };
  88. static const unsigned char romfs_dtype_table[] = {
  89. DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_SOCK, DT_FIFO
  90. };
  91. static struct inode *romfs_iget(struct super_block *sb, unsigned long pos);
  92. /*
  93. * read a page worth of data from the image
  94. */
  95. static int romfs_readpage(struct file *file, struct page *page)
  96. {
  97. struct inode *inode = page->mapping->host;
  98. loff_t offset, size;
  99. unsigned long fillsize, pos;
  100. void *buf;
  101. int ret;
  102. buf = kmap(page);
  103. if (!buf)
  104. return -ENOMEM;
  105. /* 32 bit warning -- but not for us :) */
  106. offset = page_offset(page);
  107. size = i_size_read(inode);
  108. fillsize = 0;
  109. ret = 0;
  110. if (offset < size) {
  111. size -= offset;
  112. fillsize = size > PAGE_SIZE ? PAGE_SIZE : size;
  113. pos = ROMFS_I(inode)->i_dataoffset + offset;
  114. ret = romfs_dev_read(inode->i_sb, pos, buf, fillsize);
  115. if (ret < 0) {
  116. SetPageError(page);
  117. fillsize = 0;
  118. ret = -EIO;
  119. }
  120. }
  121. if (fillsize < PAGE_SIZE)
  122. memset(buf + fillsize, 0, PAGE_SIZE - fillsize);
  123. if (ret == 0)
  124. SetPageUptodate(page);
  125. flush_dcache_page(page);
  126. kunmap(page);
  127. unlock_page(page);
  128. return ret;
  129. }
  130. static const struct address_space_operations romfs_aops = {
  131. .readpage = romfs_readpage
  132. };
  133. /*
  134. * read the entries from a directory
  135. */
  136. static int romfs_readdir(struct file *file, struct dir_context *ctx)
  137. {
  138. struct inode *i = file_inode(file);
  139. struct romfs_inode ri;
  140. unsigned long offset, maxoff;
  141. int j, ino, nextfh;
  142. char fsname[ROMFS_MAXFN]; /* XXX dynamic? */
  143. int ret;
  144. maxoff = romfs_maxsize(i->i_sb);
  145. offset = ctx->pos;
  146. if (!offset) {
  147. offset = i->i_ino & ROMFH_MASK;
  148. ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE);
  149. if (ret < 0)
  150. goto out;
  151. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  152. }
  153. /* Not really failsafe, but we are read-only... */
  154. for (;;) {
  155. if (!offset || offset >= maxoff) {
  156. offset = maxoff;
  157. ctx->pos = offset;
  158. goto out;
  159. }
  160. ctx->pos = offset;
  161. /* Fetch inode info */
  162. ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE);
  163. if (ret < 0)
  164. goto out;
  165. j = romfs_dev_strnlen(i->i_sb, offset + ROMFH_SIZE,
  166. sizeof(fsname) - 1);
  167. if (j < 0)
  168. goto out;
  169. ret = romfs_dev_read(i->i_sb, offset + ROMFH_SIZE, fsname, j);
  170. if (ret < 0)
  171. goto out;
  172. fsname[j] = '\0';
  173. ino = offset;
  174. nextfh = be32_to_cpu(ri.next);
  175. if ((nextfh & ROMFH_TYPE) == ROMFH_HRD)
  176. ino = be32_to_cpu(ri.spec);
  177. if (!dir_emit(ctx, fsname, j, ino,
  178. romfs_dtype_table[nextfh & ROMFH_TYPE]))
  179. goto out;
  180. offset = nextfh & ROMFH_MASK;
  181. }
  182. out:
  183. return 0;
  184. }
  185. /*
  186. * look up an entry in a directory
  187. */
  188. static struct dentry *romfs_lookup(struct inode *dir, struct dentry *dentry,
  189. unsigned int flags)
  190. {
  191. unsigned long offset, maxoff;
  192. struct inode *inode = NULL;
  193. struct romfs_inode ri;
  194. const char *name; /* got from dentry */
  195. int len, ret;
  196. offset = dir->i_ino & ROMFH_MASK;
  197. ret = romfs_dev_read(dir->i_sb, offset, &ri, ROMFH_SIZE);
  198. if (ret < 0)
  199. goto error;
  200. /* search all the file entries in the list starting from the one
  201. * pointed to by the directory's special data */
  202. maxoff = romfs_maxsize(dir->i_sb);
  203. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  204. name = dentry->d_name.name;
  205. len = dentry->d_name.len;
  206. for (;;) {
  207. if (!offset || offset >= maxoff)
  208. break;
  209. ret = romfs_dev_read(dir->i_sb, offset, &ri, sizeof(ri));
  210. if (ret < 0)
  211. goto error;
  212. /* try to match the first 16 bytes of name */
  213. ret = romfs_dev_strcmp(dir->i_sb, offset + ROMFH_SIZE, name,
  214. len);
  215. if (ret < 0)
  216. goto error;
  217. if (ret == 1) {
  218. /* Hard link handling */
  219. if ((be32_to_cpu(ri.next) & ROMFH_TYPE) == ROMFH_HRD)
  220. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  221. inode = romfs_iget(dir->i_sb, offset);
  222. break;
  223. }
  224. /* next entry */
  225. offset = be32_to_cpu(ri.next) & ROMFH_MASK;
  226. }
  227. return d_splice_alias(inode, dentry);
  228. error:
  229. return ERR_PTR(ret);
  230. }
  231. static const struct file_operations romfs_dir_operations = {
  232. .read = generic_read_dir,
  233. .iterate_shared = romfs_readdir,
  234. .llseek = generic_file_llseek,
  235. };
  236. static const struct inode_operations romfs_dir_inode_operations = {
  237. .lookup = romfs_lookup,
  238. };
  239. /*
  240. * get a romfs inode based on its position in the image (which doubles as the
  241. * inode number)
  242. */
  243. static struct inode *romfs_iget(struct super_block *sb, unsigned long pos)
  244. {
  245. struct romfs_inode_info *inode;
  246. struct romfs_inode ri;
  247. struct inode *i;
  248. unsigned long nlen;
  249. unsigned nextfh;
  250. int ret;
  251. umode_t mode;
  252. /* we might have to traverse a chain of "hard link" file entries to get
  253. * to the actual file */
  254. for (;;) {
  255. ret = romfs_dev_read(sb, pos, &ri, sizeof(ri));
  256. if (ret < 0)
  257. goto error;
  258. /* XXX: do romfs_checksum here too (with name) */
  259. nextfh = be32_to_cpu(ri.next);
  260. if ((nextfh & ROMFH_TYPE) != ROMFH_HRD)
  261. break;
  262. pos = be32_to_cpu(ri.spec) & ROMFH_MASK;
  263. }
  264. /* determine the length of the filename */
  265. nlen = romfs_dev_strnlen(sb, pos + ROMFH_SIZE, ROMFS_MAXFN);
  266. if (IS_ERR_VALUE(nlen))
  267. goto eio;
  268. /* get an inode for this image position */
  269. i = iget_locked(sb, pos);
  270. if (!i)
  271. return ERR_PTR(-ENOMEM);
  272. if (!(i->i_state & I_NEW))
  273. return i;
  274. /* precalculate the data offset */
  275. inode = ROMFS_I(i);
  276. inode->i_metasize = (ROMFH_SIZE + nlen + 1 + ROMFH_PAD) & ROMFH_MASK;
  277. inode->i_dataoffset = pos + inode->i_metasize;
  278. set_nlink(i, 1); /* Hard to decide.. */
  279. i->i_size = be32_to_cpu(ri.size);
  280. i->i_mtime.tv_sec = i->i_atime.tv_sec = i->i_ctime.tv_sec = 0;
  281. i->i_mtime.tv_nsec = i->i_atime.tv_nsec = i->i_ctime.tv_nsec = 0;
  282. /* set up mode and ops */
  283. mode = romfs_modemap[nextfh & ROMFH_TYPE];
  284. switch (nextfh & ROMFH_TYPE) {
  285. case ROMFH_DIR:
  286. i->i_size = ROMFS_I(i)->i_metasize;
  287. i->i_op = &romfs_dir_inode_operations;
  288. i->i_fop = &romfs_dir_operations;
  289. if (nextfh & ROMFH_EXEC)
  290. mode |= S_IXUGO;
  291. break;
  292. case ROMFH_REG:
  293. i->i_fop = &romfs_ro_fops;
  294. i->i_data.a_ops = &romfs_aops;
  295. if (nextfh & ROMFH_EXEC)
  296. mode |= S_IXUGO;
  297. break;
  298. case ROMFH_SYM:
  299. i->i_op = &page_symlink_inode_operations;
  300. inode_nohighmem(i);
  301. i->i_data.a_ops = &romfs_aops;
  302. mode |= S_IRWXUGO;
  303. break;
  304. default:
  305. /* depending on MBZ for sock/fifos */
  306. nextfh = be32_to_cpu(ri.spec);
  307. init_special_inode(i, mode, MKDEV(nextfh >> 16,
  308. nextfh & 0xffff));
  309. break;
  310. }
  311. i->i_mode = mode;
  312. unlock_new_inode(i);
  313. return i;
  314. eio:
  315. ret = -EIO;
  316. error:
  317. pr_err("read error for inode 0x%lx\n", pos);
  318. return ERR_PTR(ret);
  319. }
  320. /*
  321. * allocate a new inode
  322. */
  323. static struct inode *romfs_alloc_inode(struct super_block *sb)
  324. {
  325. struct romfs_inode_info *inode;
  326. inode = kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
  327. return inode ? &inode->vfs_inode : NULL;
  328. }
  329. /*
  330. * return a spent inode to the slab cache
  331. */
  332. static void romfs_i_callback(struct rcu_head *head)
  333. {
  334. struct inode *inode = container_of(head, struct inode, i_rcu);
  335. kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
  336. }
  337. static void romfs_destroy_inode(struct inode *inode)
  338. {
  339. call_rcu(&inode->i_rcu, romfs_i_callback);
  340. }
  341. /*
  342. * get filesystem statistics
  343. */
  344. static int romfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  345. {
  346. struct super_block *sb = dentry->d_sb;
  347. u64 id = 0;
  348. /* When calling huge_encode_dev(),
  349. * use sb->s_bdev->bd_dev when,
  350. * - CONFIG_ROMFS_ON_BLOCK defined
  351. * use sb->s_dev when,
  352. * - CONFIG_ROMFS_ON_BLOCK undefined and
  353. * - CONFIG_ROMFS_ON_MTD defined
  354. * leave id as 0 when,
  355. * - CONFIG_ROMFS_ON_BLOCK undefined and
  356. * - CONFIG_ROMFS_ON_MTD undefined
  357. */
  358. if (sb->s_bdev)
  359. id = huge_encode_dev(sb->s_bdev->bd_dev);
  360. else if (sb->s_dev)
  361. id = huge_encode_dev(sb->s_dev);
  362. buf->f_type = ROMFS_MAGIC;
  363. buf->f_namelen = ROMFS_MAXFN;
  364. buf->f_bsize = ROMBSIZE;
  365. buf->f_bfree = buf->f_bavail = buf->f_ffree;
  366. buf->f_blocks =
  367. (romfs_maxsize(dentry->d_sb) + ROMBSIZE - 1) >> ROMBSBITS;
  368. buf->f_fsid.val[0] = (u32)id;
  369. buf->f_fsid.val[1] = (u32)(id >> 32);
  370. return 0;
  371. }
  372. /*
  373. * remounting must involve read-only
  374. */
  375. static int romfs_remount(struct super_block *sb, int *flags, char *data)
  376. {
  377. sync_filesystem(sb);
  378. *flags |= SB_RDONLY;
  379. return 0;
  380. }
  381. static const struct super_operations romfs_super_ops = {
  382. .alloc_inode = romfs_alloc_inode,
  383. .destroy_inode = romfs_destroy_inode,
  384. .statfs = romfs_statfs,
  385. .remount_fs = romfs_remount,
  386. };
  387. /*
  388. * checksum check on part of a romfs filesystem
  389. */
  390. static __u32 romfs_checksum(const void *data, int size)
  391. {
  392. const __be32 *ptr = data;
  393. __u32 sum;
  394. sum = 0;
  395. size >>= 2;
  396. while (size > 0) {
  397. sum += be32_to_cpu(*ptr++);
  398. size--;
  399. }
  400. return sum;
  401. }
  402. /*
  403. * fill in the superblock
  404. */
  405. static int romfs_fill_super(struct super_block *sb, void *data, int silent)
  406. {
  407. struct romfs_super_block *rsb;
  408. struct inode *root;
  409. unsigned long pos, img_size;
  410. const char *storage;
  411. size_t len;
  412. int ret;
  413. #ifdef CONFIG_BLOCK
  414. if (!sb->s_mtd) {
  415. sb_set_blocksize(sb, ROMBSIZE);
  416. } else {
  417. sb->s_blocksize = ROMBSIZE;
  418. sb->s_blocksize_bits = blksize_bits(ROMBSIZE);
  419. }
  420. #endif
  421. sb->s_maxbytes = 0xFFFFFFFF;
  422. sb->s_magic = ROMFS_MAGIC;
  423. sb->s_flags |= SB_RDONLY | SB_NOATIME;
  424. sb->s_op = &romfs_super_ops;
  425. #ifdef CONFIG_ROMFS_ON_MTD
  426. /* Use same dev ID from the underlying mtdblock device */
  427. if (sb->s_mtd)
  428. sb->s_dev = MKDEV(MTD_BLOCK_MAJOR, sb->s_mtd->index);
  429. #endif
  430. /* read the image superblock and check it */
  431. rsb = kmalloc(512, GFP_KERNEL);
  432. if (!rsb)
  433. return -ENOMEM;
  434. sb->s_fs_info = (void *) 512;
  435. ret = romfs_dev_read(sb, 0, rsb, 512);
  436. if (ret < 0)
  437. goto error_rsb;
  438. img_size = be32_to_cpu(rsb->size);
  439. if (sb->s_mtd && img_size > sb->s_mtd->size)
  440. goto error_rsb_inval;
  441. sb->s_fs_info = (void *) img_size;
  442. if (rsb->word0 != ROMSB_WORD0 || rsb->word1 != ROMSB_WORD1 ||
  443. img_size < ROMFH_SIZE) {
  444. if (!silent)
  445. pr_warn("VFS: Can't find a romfs filesystem on dev %s.\n",
  446. sb->s_id);
  447. goto error_rsb_inval;
  448. }
  449. if (romfs_checksum(rsb, min_t(size_t, img_size, 512))) {
  450. pr_err("bad initial checksum on dev %s.\n", sb->s_id);
  451. goto error_rsb_inval;
  452. }
  453. storage = sb->s_mtd ? "MTD" : "the block layer";
  454. len = strnlen(rsb->name, ROMFS_MAXFN);
  455. if (!silent)
  456. pr_notice("Mounting image '%*.*s' through %s\n",
  457. (unsigned) len, (unsigned) len, rsb->name, storage);
  458. kfree(rsb);
  459. rsb = NULL;
  460. /* find the root directory */
  461. pos = (ROMFH_SIZE + len + 1 + ROMFH_PAD) & ROMFH_MASK;
  462. root = romfs_iget(sb, pos);
  463. if (IS_ERR(root))
  464. return PTR_ERR(root);
  465. sb->s_root = d_make_root(root);
  466. if (!sb->s_root)
  467. return -ENOMEM;
  468. return 0;
  469. error_rsb_inval:
  470. ret = -EINVAL;
  471. error_rsb:
  472. kfree(rsb);
  473. return ret;
  474. }
  475. /*
  476. * get a superblock for mounting
  477. */
  478. static struct dentry *romfs_mount(struct file_system_type *fs_type,
  479. int flags, const char *dev_name,
  480. void *data)
  481. {
  482. struct dentry *ret = ERR_PTR(-EINVAL);
  483. #ifdef CONFIG_ROMFS_ON_MTD
  484. ret = mount_mtd(fs_type, flags, dev_name, data, romfs_fill_super);
  485. #endif
  486. #ifdef CONFIG_ROMFS_ON_BLOCK
  487. if (ret == ERR_PTR(-EINVAL))
  488. ret = mount_bdev(fs_type, flags, dev_name, data,
  489. romfs_fill_super);
  490. #endif
  491. return ret;
  492. }
  493. /*
  494. * destroy a romfs superblock in the appropriate manner
  495. */
  496. static void romfs_kill_sb(struct super_block *sb)
  497. {
  498. #ifdef CONFIG_ROMFS_ON_MTD
  499. if (sb->s_mtd) {
  500. kill_mtd_super(sb);
  501. return;
  502. }
  503. #endif
  504. #ifdef CONFIG_ROMFS_ON_BLOCK
  505. if (sb->s_bdev) {
  506. kill_block_super(sb);
  507. return;
  508. }
  509. #endif
  510. }
  511. static struct file_system_type romfs_fs_type = {
  512. .owner = THIS_MODULE,
  513. .name = "romfs",
  514. .mount = romfs_mount,
  515. .kill_sb = romfs_kill_sb,
  516. .fs_flags = FS_REQUIRES_DEV,
  517. };
  518. MODULE_ALIAS_FS("romfs");
  519. /*
  520. * inode storage initialiser
  521. */
  522. static void romfs_i_init_once(void *_inode)
  523. {
  524. struct romfs_inode_info *inode = _inode;
  525. inode_init_once(&inode->vfs_inode);
  526. }
  527. /*
  528. * romfs module initialisation
  529. */
  530. static int __init init_romfs_fs(void)
  531. {
  532. int ret;
  533. pr_info("ROMFS MTD (C) 2007 Red Hat, Inc.\n");
  534. romfs_inode_cachep =
  535. kmem_cache_create("romfs_i",
  536. sizeof(struct romfs_inode_info), 0,
  537. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
  538. SLAB_ACCOUNT, romfs_i_init_once);
  539. if (!romfs_inode_cachep) {
  540. pr_err("Failed to initialise inode cache\n");
  541. return -ENOMEM;
  542. }
  543. ret = register_filesystem(&romfs_fs_type);
  544. if (ret) {
  545. pr_err("Failed to register filesystem\n");
  546. goto error_register;
  547. }
  548. return 0;
  549. error_register:
  550. kmem_cache_destroy(romfs_inode_cachep);
  551. return ret;
  552. }
  553. /*
  554. * romfs module removal
  555. */
  556. static void __exit exit_romfs_fs(void)
  557. {
  558. unregister_filesystem(&romfs_fs_type);
  559. /*
  560. * Make sure all delayed rcu free inodes are flushed before we
  561. * destroy cache.
  562. */
  563. rcu_barrier();
  564. kmem_cache_destroy(romfs_inode_cachep);
  565. }
  566. module_init(init_romfs_fs);
  567. module_exit(exit_romfs_fs);
  568. MODULE_DESCRIPTION("Direct-MTD Capable RomFS");
  569. MODULE_AUTHOR("Red Hat, Inc.");
  570. MODULE_LICENSE("GPL"); /* Actually dual-licensed, but it doesn't matter for */