home *** CD-ROM | disk | FTP | other *** search
/ ftp.parl.clemson.edu / 2015-02-07.ftp.parl.clemson.edu.tar / ftp.parl.clemson.edu / pub / pvfs2 / orangefs-2.8.3-20110323.tar.gz / orangefs-2.8.3-20110323.tar / orangefs / patches / posix-ext / posix-extensions-cvs.patch < prev    next >
Text File  |  2008-01-07  |  35KB  |  1,039 lines
  1. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/arch/i386/kernel/syscall_table.S vanilla-new/arch/i386/kernel/syscall_table.S
  2. --- vanilla/arch/i386/kernel/syscall_table.S    2006-03-19 23:53:29.000000000 -0600
  3. +++ vanilla-new/arch/i386/kernel/syscall_table.S    2006-04-07 10:28:39.000000000 -0500
  4. @@ -310,3 +310,5 @@
  5.      .long sys_pselect6
  6.      .long sys_ppoll
  7.      .long sys_unshare        /* 310 */
  8. +    .long sys_openg
  9. +    .long sys_openfh
  10. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/arch/ia64/kernel/entry.S vanilla-new/arch/ia64/kernel/entry.S
  11. --- vanilla/arch/ia64/kernel/entry.S    2006-03-19 23:53:29.000000000 -0600
  12. +++ vanilla-new/arch/ia64/kernel/entry.S    2006-04-07 10:28:39.000000000 -0500
  13. @@ -1619,5 +1619,7 @@
  14.      data8 sys_ni_syscall            // reserved for pselect
  15.      data8 sys_ni_syscall            // 1295 reserved for ppoll
  16.      data8 sys_unshare
  17. +    data8 sys_openg
  18. +    data8 sys_openfh
  19.  
  20.      .org sys_call_table + 8*NR_syscalls    // guard against failures to increase NR_syscalls
  21. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/arch/powerpc/kernel/systbl.S vanilla-new/arch/powerpc/kernel/systbl.S
  22. --- vanilla/arch/powerpc/kernel/systbl.S    2006-03-19 23:53:29.000000000 -0600
  23. +++ vanilla-new/arch/powerpc/kernel/systbl.S    2006-04-07 10:28:39.000000000 -0500
  24. @@ -322,3 +322,5 @@
  25.  COMPAT_SYS(pselect6)
  26.  COMPAT_SYS(ppoll)
  27.  SYSCALL(unshare)
  28. +SYSCALL(openg)
  29. +SYSCALL(openfh)
  30. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/arch/x86_64/ia32/ia32entry.S vanilla-new/arch/x86_64/ia32/ia32entry.S
  31. --- vanilla/arch/x86_64/ia32/ia32entry.S    2006-03-19 23:53:29.000000000 -0600
  32. +++ vanilla-new/arch/x86_64/ia32/ia32entry.S    2006-04-07 10:28:39.000000000 -0500
  33. @@ -688,6 +688,8 @@
  34.      .quad sys_ni_syscall        /* pselect6 for now */
  35.      .quad sys_ni_syscall        /* ppoll for now */
  36.      .quad sys_unshare        /* 310 */
  37. +    .quad compat_sys_openg
  38. +    .quad compat_sys_openfh
  39.  ia32_syscall_end:        
  40.      .rept IA32_NR_syscalls-(ia32_syscall_end-ia32_sys_call_table)/8
  41.          .quad ni_syscall
  42. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/fs/compat.c vanilla-new/fs/compat.c
  43. --- vanilla/fs/compat.c    2006-03-19 23:53:29.000000000 -0600
  44. +++ vanilla-new/fs/compat.c    2006-04-07 13:39:13.000000000 -0500
  45. @@ -1332,6 +1332,27 @@
  46.  }
  47.  
  48.  /*
  49. + * Exactly like fs/open.c: sys_openg(), except that it doesn't set the 
  50. + * O_LARGEFILE flag.
  51. + */
  52. +asmlinkage long
  53. +compat_sys_openg(const char __user *pathname, void __user *uhandle, size_t __user *uhandle_len,
  54. +        int flags, int mode)
  55. +{
  56. +    return do_sys_openg(pathname, uhandle, uhandle_len, flags, mode);
  57. +}
  58. +
  59. +/*
  60. + * Exactly like fs/open.c: sys_openg(), except that it doesn't set the 
  61. + * O_LARGEFILE flag.
  62. + */
  63. +asmlinkage long
  64. +compat_sys_openfh(const char __user *uhandle, int uhandle_len)
  65. +{
  66. +    return do_sys_openfh(uhandle, uhandle_len);
  67. +}
  68. +
  69. +/*
  70.   * compat_count() counts the number of arguments/envelopes. It is basically
  71.   * a copy of count() from fs/exec.c, except that it works with 32 bit argv
  72.   * and envp pointers.
  73. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/fs/open.c vanilla-new/fs/open.c
  74. --- vanilla/fs/open.c    2006-03-19 23:53:29.000000000 -0600
  75. +++ vanilla-new/fs/open.c    2006-04-26 22:06:15.000000000 -0500
  76. @@ -27,9 +27,37 @@
  77.  #include <linux/pagemap.h>
  78.  #include <linux/syscalls.h>
  79.  #include <linux/rcupdate.h>
  80. +#include <linux/scatterlist.h>
  81. +#include <linux/crypto.h>
  82. +#include <linux/types.h>
  83.  
  84.  #include <asm/unistd.h>
  85.  
  86. +void get_filesystem(struct file_system_type *fs);
  87. +void put_filesystem(struct file_system_type *fs);
  88. +struct file_system_type *get_fs_type(const char *name);
  89. +
  90. +int vfs_statfs_lite(struct super_block *sb, struct kstatfs *buf, int statfs_mask)
  91. +{
  92. +    int retval = -ENODEV;
  93. +
  94. +    if (sb) {
  95. +        retval = -ENOSYS;
  96. +        if (sb->s_op->statfs_lite) {
  97. +            memset(buf, 0, sizeof(*buf));
  98. +            retval = security_sb_statfs(sb);
  99. +            if (retval)
  100. +                return retval;
  101. +            retval = sb->s_op->statfs_lite(sb, buf, statfs_mask);
  102. +            if (retval == 0 && buf->f_frsize == 0 && (statfs_mask & STATFS_M_FRSIZE) != 0)
  103. +                buf->f_frsize = buf->f_bsize;
  104. +        }
  105. +    }
  106. +    return retval;
  107. +}
  108. +
  109. +EXPORT_SYMBOL(vfs_statfs_lite);
  110. +
  111.  int vfs_statfs(struct super_block *sb, struct kstatfs *buf)
  112.  {
  113.      int retval = -ENODEV;
  114. @@ -1100,6 +1128,638 @@
  115.  }
  116.  EXPORT_SYMBOL_GPL(sys_openat);
  117.  
  118. +static unsigned int diff(struct timeval *end, struct timeval *begin)
  119. +{
  120. +    if (end->tv_usec < begin->tv_usec) {
  121. +        end->tv_usec += 1000000; end->tv_sec--;
  122. +    }
  123. +    end->tv_sec  -= begin->tv_sec;
  124. +    end->tv_usec -= begin->tv_usec;
  125. +    return ((end->tv_sec * 1000000) + (end->tv_usec));
  126. +}
  127. +
  128. +/*
  129. + * Compute a simple crc checksum
  130. + */
  131. +static inline __u32 simple_crc_csum(struct file_handle *fhandle)
  132. +{
  133. +    struct file_handle_generic *fhg;
  134. +    __le32 *u;
  135. +    __u8 *c;
  136. +    __u32 i, j;
  137. +    
  138. +    fhg = &fhandle->fh_generic;
  139. +    /* upto and not including the fhg_crc_csum field */
  140. +    for (i = 0, u = (__le32 *) fhg; u < (__le32 *)(&fhg->fhg_crc_csum); ++u)
  141. +        i += le32_to_cpup(u);
  142. +    /* and over the entire fh_private buffer */
  143. +    c = (__u8 *) fhandle->fh_private;
  144. +    for (j = 0; j < fhandle->fh_private_length; ++j) 
  145. +        i += *(c + j);
  146. +    return i;
  147. +}
  148. +
  149. +/*
  150. + * Compute and return a crc32c checksum using the crypto subsystem
  151. + * API
  152. + */
  153. +static __u32 compute_crc32_csum(struct file_handle *fhandle)
  154. +{
  155. +#define MAX_SG_LIST 8
  156. +    __u32 csum;
  157. +    __u32 i;
  158. +    struct crypto_tfm *tfm;
  159. +    struct scatterlist sg[MAX_SG_LIST];
  160. +    struct timeval begin, end;
  161. +
  162. +    do_gettimeofday(&begin);
  163. +    if (crypto_alg_available("crc32c", 0) == 0) {
  164. +        csum = simple_crc_csum(fhandle);
  165. +        do_gettimeofday(&end);
  166. +        printk(KERN_DEBUG "compute_crc32_csum[simple]: took %d usecs\n", diff(&end, &begin));
  167. +        goto out;
  168. +    }
  169. +
  170. +    tfm = crypto_alloc_tfm("crc32c", 0);
  171. +    if (tfm == NULL) {
  172. +        csum = simple_crc_csum(fhandle);
  173. +        goto out;
  174. +    }
  175. +
  176. +    crypto_digest_init(tfm);
  177. +
  178. +    i = 0;
  179. +    sg_set_buf(&sg[i++], &fhandle->fh_generic, 
  180. +            offsetof(struct file_handle_generic, fhg_crc_csum));
  181. +    sg_set_buf(&sg[i++], fhandle->fh_private, fhandle->fh_private_length);
  182. +
  183. +    crypto_digest_update(tfm, sg, i);
  184. +    crypto_digest_final(tfm, (__u8*)&csum);
  185. +    crypto_free_tfm(tfm);
  186. +    do_gettimeofday(&end);
  187. +    printk(KERN_DEBUG "compute_crc32_csum[tfm]: took %d usecs\n", diff(&end, &begin));
  188. +out:
  189. +    return csum;
  190. +#undef MAX_SG_LIST
  191. +}
  192. +
  193. +/* 
  194. + * Store a crc32 check sum into the handle buffer
  195. + * NOTE: We expect fhandle->fh_private and fhandle->fh_private_length
  196. + * to be initialized prior to this call!
  197. + */
  198. +static inline void store_crc32_csum(struct file_handle *fhandle)
  199. +{
  200. +    /* Compute the CRC checksum over the handle buffer */
  201. +    __u32 csum = compute_crc32_csum(fhandle);
  202. +    /* Set the CRC checksum into the handle buffer */
  203. +    set_fh_field(&fhandle->fh_generic, crc_csum, csum);
  204. +    return;
  205. +}
  206. +
  207. +/* 
  208. + * Verifies if a file handle's structure's check sum
  209. + * matches with what user-space indicates.
  210. + * This should catch most of the simple buffer handle corruption
  211. + * cases (but not the maliciously crafted ones!) for which
  212. + * we have the keyed SHA1 (HMAC-SHA1) algorithm verification.
  213. + * NOTE: We expect fhandle->fh_private and fhandle->fh_private_length
  214. + * to be initialized prior to this call!
  215. + * Returns 1 in case verification was successful and 0
  216. + * otherwise.
  217. + */
  218. +static inline int verify_crc32_csum(struct file_handle *fhandle)
  219. +{
  220. +    __u32 csum, crc_csum;
  221. +
  222. +    /* Compute the CRC checksum over the handle buffer */
  223. +    csum = compute_crc32_csum(fhandle);
  224. +    /* Retrieve the CRC checksum from the handle buffer */
  225. +    get_fh_field(&fhandle->fh_generic, crc_csum, crc_csum);
  226. +    return (crc_csum == csum);
  227. +}
  228. +
  229. +/* 
  230. + * Compute a hmac-sha1 crypto check sum using a specified
  231. + * key and store it in the buffer pointed to by result.
  232. + * NOTE: We assume that fhandle->fh_private and
  233. + * fhandle->fh_private_length are initialized prior to this call.
  234. + * Returns 0 in case SHA1/HMAC-SHA1 was not built-in/compiled
  235. + * for the kernel
  236. + * Else returns length of the digest generated.
  237. + */
  238. +static unsigned int compute_hmac_sha1_csum(struct file_handle *fhandle, 
  239. +        char *key, int keylen, char *result)
  240. +{
  241. +#define MAX_SG_LIST 8
  242. +    __u32 i;
  243. +    struct crypto_tfm *tfm;
  244. +    struct scatterlist sg[MAX_SG_LIST];
  245. +    unsigned int ret;
  246. +    struct timeval begin, end;
  247. + 
  248. +    do_gettimeofday(&begin);
  249. +
  250. +    /* SHA1 is not available */
  251. +    if (crypto_alg_available("sha1", 0) == 0)
  252. +        return 0;
  253. +
  254. +    tfm = crypto_alloc_tfm("sha1", 0);
  255. +    if (tfm == NULL)
  256. +        return 0;
  257. +
  258. +    i = 0;
  259. +    sg_set_buf(&sg[i++], &fhandle->fh_generic, 
  260. +            offsetof(struct file_handle_generic, fhg_hmac_sha1));
  261. +    sg_set_buf(&sg[i++], fhandle->fh_private, fhandle->fh_private_length);
  262. +
  263. +    crypto_hmac(tfm, key, &keylen, sg, i, result);
  264. +    ret = crypto_tfm_alg_digestsize(tfm);
  265. +    crypto_free_tfm(tfm);
  266. +    do_gettimeofday(&end);
  267. +    printk(KERN_DEBUG "compute_hmac_sha1_csum: took %d usecs\n", diff(&end, &begin));
  268. +    return ret;
  269. +#undef MAX_SG_LIST
  270. +}
  271. +
  272. +/*
  273. + * Store a hmac-sha1 crypto check sum into the handle
  274. + * buffer.
  275. + */
  276. +static inline void store_hmac_csum(struct file_handle *fhandle,
  277. +        char *key, int keylen)
  278. +{
  279. +    compute_hmac_sha1_csum(fhandle, key, keylen,
  280. +            fhandle->fh_generic.fhg_hmac_sha1);
  281. +    return;
  282. +}
  283. +
  284. +/*
  285. + * Verifies if a file handle buffer's computed hmac-sha1 crypto
  286. + * check sum matches with whatever the user-space buffer claims
  287. + * Returns 1 in case verification was succesful and 0
  288. + * otherwise
  289. + */
  290. +static int verify_hmac_csum(struct file_handle *fhandle, char *key, int keylen)
  291. +{
  292. +    __u8 result[24];
  293. +    unsigned int result_len;
  294. +
  295. +    result_len = compute_hmac_sha1_csum(fhandle, key, keylen, result);
  296. +    /* Crypto is not supported. deny verification */
  297. +    if (result_len == 0) 
  298. +        return 0;
  299. +
  300. +    /* Check if user has tampered with the buffer */
  301. +    if (memcmp(fhandle->fh_generic.fhg_hmac_sha1, result, result_len) == 0)
  302. +        return 1;
  303. +    return 0;
  304. +}
  305. +
  306. +/*
  307. + * Copy the constructed file handle to a user-specified buffer.
  308. + * NOTE: We assume that fhandle->fh_private and
  309. + * fhandle->fh_private_length have been initialized
  310. + * prior to this routine
  311. + */
  312. +static int copy_handle(const void __user *uaddr, struct file_handle *fhandle)
  313. +{
  314. +    char __user *ptr = (char __user *) uaddr;
  315. +    struct timeval begin, end;
  316. + 
  317. +    do_gettimeofday(&begin);
  318. +
  319. +    /* Copy the VFS generic part of the handle */
  320. +    if (copy_to_user(ptr, &fhandle->fh_generic, 
  321. +                sizeof(struct file_handle_generic)))
  322. +        return -EFAULT;
  323. +
  324. +    /* Advance the user-buffer pointer */
  325. +    ptr += sizeof(struct file_handle_generic);
  326. +    /* Copy the FS specific part of the handle */
  327. +    if (copy_to_user(ptr, fhandle->fh_private, fhandle->fh_private_length))
  328. +        return -EFAULT;
  329. +    do_gettimeofday(&end);
  330. +    printk(KERN_DEBUG "copy_handle: took %d usecs\n", diff(&end, &begin));
  331. +    return 0;
  332. +}
  333. +
  334. +/*
  335. + * Copy a user-specified handle buffer to a temporary
  336. + * kernel buffer.
  337. + */
  338. +static void* move_handle_to_kernel(const void __user *uaddr, 
  339. +        size_t ulen, void *kaddr)
  340. +{
  341. +    if (uaddr != NULL) {
  342. +        if (copy_from_user(kaddr, uaddr, ulen))
  343. +            return ERR_PTR(-EFAULT);
  344. +    }
  345. +    return kaddr;
  346. +}
  347. +
  348. +/*
  349. + * Copy a specified size user-space handle buffer to a temporary
  350. + * kernel buffer and return a pointer to the kernel buffer.
  351. + * Encodes error in return pointer in case 
  352. + * operation failed for some reason.
  353. + */
  354. +static void *gethandle(const void __user *uhandle, size_t uhandle_len)
  355. +{
  356. +    void *tmp = NULL, *result = ERR_PTR(-EINVAL);
  357. +    struct timeval begin, end;
  358. + 
  359. +    do_gettimeofday(&begin);
  360. +
  361. +    do {
  362. +        if (uhandle_len <= 0 || uhandle_len > MAX_HANDLE_LEN) 
  363. +            break;
  364. +        result = ERR_PTR(-ENOMEM);
  365. +        tmp = kmalloc(uhandle_len, GFP_KERNEL);
  366. +        if (tmp == NULL) 
  367. +            break;
  368. +        result = move_handle_to_kernel(uhandle, uhandle_len, tmp);
  369. +    } while (0);
  370. +    do_gettimeofday(&end);
  371. +    printk(KERN_DEBUG "gethandle: took %d usecs\n", diff(&end, &begin));
  372. +    return result;
  373. +}
  374. +/*
  375. + * Frees memory allocated to a temporary kernel space buffer
  376. + * used for staging the handle copy from user-space.
  377. + */
  378. +static void puthandle(void *handle)
  379. +{
  380. +    if (handle)
  381. +        kfree(handle);
  382. +    return;
  383. +}
  384. +
  385. +/*
  386. + * Wrapper routine to obtain any FS specific keys that can be used
  387. + * for the HMAC-SHA1 calculation to make the handle returned
  388. + * by openg() tamper-proof or atleast tamper-detectable.
  389. + *    We dont use any keys in case FS does not provide one!
  390. + */
  391. +static void get_fs_key(struct super_block *sb, char **ppkey, int *keylen)
  392. +{
  393. +    struct timeval begin, end;
  394. +
  395. +    *ppkey = NULL;
  396. +    *keylen = 0;
  397. +    do_gettimeofday(&begin);
  398. +    /* underlying fs wishes to provide a key */
  399. +    if (sb && sb->s_op && sb->s_op->get_fs_key)
  400. +        sb->s_op->get_fs_key(sb, ppkey, keylen);
  401. +    do_gettimeofday(&end);
  402. +    printk(KERN_DEBUG "get_fs_key: took %d usecs\n", diff(&end, &begin));
  403. +    return;
  404. +}
  405. +
  406. +/*
  407. + * Free the memory allocated to fhandle->fh_private.
  408. + * This is done by either calling the provided destructor
  409. + * function if any (supplied by fill_handle callback of FS).
  410. + * or by calling kfree(). We expect FS to either use kmalloc()
  411. + * or supply a dtor function so that fh_private can be properly
  412. + * deallocated.
  413. + */
  414. +static void drop_file_handle_private(struct file_handle *fhandle)
  415. +{
  416. +    if (!fhandle || !fhandle->fh_private)
  417. +        return;
  418. +    if (fhandle->fh_private_dtor) 
  419. +        fhandle->fh_private_dtor(fhandle->fh_private);
  420. +    else 
  421. +        kfree(fhandle->fh_private);
  422. +    fhandle->fh_private = NULL;
  423. +    return;
  424. +}
  425. +
  426. +/*
  427. + * Associate and establish a file handle to a struct file mapping.
  428. + * NOTE: Linux VFS is inherently based off a dentry cache model
  429. + * and since we dont have any pathnames/filenames we need to create a anon.
  430. + * dentry to represent files opened using this system call.
  431. + */
  432. +static struct file *do_fh_open(const void *handle, size_t handle_len)
  433. +{
  434. +    struct file *filp = NULL;
  435. +    struct super_block *sb;
  436. +    struct inode *inode = NULL;
  437. +    struct file_handle fhandle;
  438. +    size_t min_len = sizeof(struct file_handle_generic);
  439. +    char *key = NULL;
  440. +    int   keylen = 0;
  441. +    struct timeval begin, end;
  442. +    
  443. +    /* Do some sanity checks on the handle lengths and handle buffer */
  444. +    if (handle_len <= min_len)
  445. +        return ERR_PTR(-EINVAL);
  446. +
  447. +    memcpy(&fhandle.fh_generic, handle, min_len);
  448. +    /* set the fields of the file handle prior to verification */
  449. +    fhandle.fh_private = (char *) handle + min_len;
  450. +    fhandle.fh_private_length = (handle_len - min_len);
  451. +    fhandle.fh_private_dtor = NULL;
  452. +    /* verify crc32 checksum on the handle buffer */
  453. +    if (!verify_crc32_csum(&fhandle))
  454. +        return ERR_PTR(-EACCES);
  455. +
  456. +    /*
  457. +     * Verification of HMAC SHA1 csum on the handle buffer cannot be 
  458. +     * done at this point  since we don't know which file
  459. +     * system/superblock it belongs to.
  460. +     */
  461. +
  462. +    /* Locate and get an active reference to a 
  463. +     * super-block that matches a given handle 
  464. +     */
  465. +    do_gettimeofday(&begin);
  466. +    sb = get_sb_handle(&fhandle);
  467. +    /* could not find any valid FS that owns this handle */
  468. +    if (!sb)
  469. +        return ERR_PTR(-EINVAL);
  470. +
  471. +    do_gettimeofday(&end);
  472. +    printk(KERN_DEBUG "get_sb_handle: took %d usecs\n", diff(&end, &begin));
  473. +    /* FS has not implemented a routine to query inode based on handle */
  474. +    if (!sb->s_op || !sb->s_op->find_inode_handle) {
  475. +        filp = ERR_PTR(-EOPNOTSUPP);
  476. +        goto out;
  477. +    }
  478. +    /* Check if underlying FS wishes to use a key */
  479. +    get_fs_key(sb, &key, &keylen);
  480. +    /* and verify the authenticity of the handle buffer */
  481. +    if (verify_hmac_csum(&fhandle, key, keylen) == 0) {
  482. +        /* Permission denied */
  483. +        filp = ERR_PTR(-EACCES);
  484. +        goto out;
  485. +    }
  486. +    do_gettimeofday(&begin);
  487. +    /* find an inode or allocate/lookup an inode based on the handle */
  488. +    inode = sb->s_op->find_inode_handle(sb, &fhandle);
  489. +    if (!IS_ERR(inode)) {
  490. +        struct dentry *anon_dentry;
  491. +        int flags = 0;
  492. +
  493. +        do_gettimeofday(&end);
  494. +        printk(KERN_DEBUG "s_op->find_inode_handle: took %d usecs\n", diff(&end, &begin));
  495. +
  496. +        get_fh_field(&fhandle.fh_generic, flags, flags);
  497. +        /* 
  498. +         * Associate a anonymous dentry to this inode in case there is none.
  499. +         * d_prune_aliases() will take care of freeeing all these dentries
  500. +         * which is called when the last reference to iput() calls
  501. +         * put_inode() which in turn calls the above function.
  502. +         */
  503. +        do_gettimeofday(&begin);
  504. +        anon_dentry = d_alloc_anon(inode);
  505. +        if (anon_dentry == NULL) {
  506. +            filp = ERR_PTR(-ENOMEM);
  507. +            goto drop_inode;
  508. +        }
  509. +        /* and setup file and inode mapping */
  510. +        filp = get_empty_filp();
  511. +        if (filp == NULL) {
  512. +            filp = ERR_PTR(-ENFILE);
  513. +            goto drop_dentry;
  514. +        }
  515. +        filp = __dentry_open(anon_dentry, NULL, flags, filp, NULL);
  516. +        if (IS_ERR(filp)) {
  517. +            /* in case of error __dentry_open drops the anon_dentry */
  518. +            goto drop_inode;
  519. +    drop_dentry:
  520. +            dput(anon_dentry);
  521. +    drop_inode:
  522. +            iput(inode);
  523. +        }
  524. +        else {
  525. +            do_gettimeofday(&end);
  526. +            printk(KERN_DEBUG "d_alloc_anon + misc.: took %d usecs\n", diff(&end, &begin));
  527. +        }
  528. +    }
  529. +    else {
  530. +        /* in case of error */
  531. +        filp = ERR_PTR(PTR_ERR(inode));
  532. +    }
  533. +out:
  534. +    /* drop our active reference to sb */
  535. +    drop_super(sb);
  536. +    return filp;
  537. +}
  538. +
  539. +long do_sys_openfh(const void __user *uhandle, size_t handle_len)
  540. +{
  541. +    void *tmp = gethandle(uhandle, handle_len);
  542. +    int fd = PTR_ERR(tmp);
  543. +
  544. +    if (!IS_ERR(tmp)) {
  545. +        struct timeval begin, end;
  546. +
  547. +        do_gettimeofday(&begin);
  548. +        fd = get_unused_fd();
  549. +        do_gettimeofday(&end);
  550. +        printk(KERN_DEBUG "get_unused_fd: took %d usecs\n", diff(&end, &begin));
  551. +        if (fd >= 0) {
  552. +            struct file *f;
  553. +
  554. +            do_gettimeofday(&begin);
  555. +            f = do_fh_open(tmp, handle_len);
  556. +            if (IS_ERR(f)) {
  557. +                put_unused_fd(fd);
  558. +                fd = PTR_ERR(f);
  559. +            } else {
  560. +                do_gettimeofday(&end);
  561. +                printk(KERN_DEBUG "do_fh_open: took %d usecs\n", diff(&end, &begin));
  562. +                do_gettimeofday(&begin);
  563. +                /* this file descriptor needs to be closed on exec */
  564. +                set_close_on_exec(fd, 1);
  565. +                fd_install(fd, f);
  566. +                do_gettimeofday(&end);
  567. +                printk(KERN_DEBUG "set_close, fd_install: took %d usecs\n", diff(&end, &begin));
  568. +            }
  569. +        }
  570. +        puthandle(tmp);
  571. +    }
  572. +    return fd;
  573. +}
  574. +
  575. +asmlinkage long sys_openfh(const void __user *uhandle, size_t handle_len)
  576. +{
  577. +    return do_sys_openfh(uhandle, handle_len);
  578. +}
  579. +
  580. +EXPORT_SYMBOL_GPL(sys_openfh);
  581. +
  582. +long do_sys_openg(const char __user *pathname, void __user *uhandle,
  583. +        size_t __user *uhandle_len, int flags, int mode)
  584. +{
  585. +    char *tmp = getname(pathname);
  586. +    long err = PTR_ERR(tmp);
  587. +
  588. +    if (!IS_ERR(tmp)) 
  589. +    {
  590. +        struct file *f = NULL;
  591. +        size_t handle_len = 0;
  592. +        size_t min_len = sizeof(struct file_handle_generic);
  593. +        struct file_handle fhandle;
  594. +        struct timeval begin, end;
  595. +
  596. +        memset(&fhandle, 0, sizeof(fhandle));
  597. +        if (get_user(handle_len, uhandle_len)) {
  598. +            err = -EFAULT;
  599. +            goto drop_name;
  600. +        }
  601. +        /* discard bogus values */
  602. +        if (handle_len < 0)
  603. +        {
  604. +            err = -EINVAL;
  605. +            goto drop_name;
  606. +        }
  607. +        /* or definitely insufficient buffer length */
  608. +        else if (handle_len > 0 && 
  609. +                handle_len < min_len)
  610. +        {
  611. +            err = -ERANGE;
  612. +            goto drop_name;
  613. +        }
  614. +        err = 0;
  615. +        do_gettimeofday(&begin);
  616. +        /* Try to open the file now */
  617. +        f = do_filp_open(AT_FDCWD, tmp, flags, mode);
  618. +        if (IS_ERR(f)) {
  619. +            /* File does not exist */
  620. +            err = PTR_ERR(f);
  621. +            goto drop_name;
  622. +        }
  623. +        else {
  624. +            /* Is this even possible? */
  625. +            if (!f->f_dentry || !f->f_dentry->d_inode)
  626. +            {
  627. +                err = -EINVAL;
  628. +                goto drop_filp;
  629. +            }
  630. +            /* Diallow anything but regular files */
  631. +            if (!S_ISREG(f->f_dentry->d_inode->i_mode)) {
  632. +                err = -EACCES;
  633. +                goto drop_filp;
  634. +            }
  635. +            else {
  636. +                /* Does FS define callback for openg? */
  637. +                if (!f->f_dentry->d_inode->i_op->fill_handle) {
  638. +                    /* not supported */
  639. +                    err = -EOPNOTSUPP;
  640. +                    goto drop_filp;
  641. +                }
  642. +                else {
  643. +                    do_gettimeofday(&end);
  644. +                    printk(KERN_DEBUG "do_filp_open: took %d usecs\n", diff(&end, &begin));
  645. +                    fhandle.fh_private = NULL;
  646. +                    fhandle.fh_private_length = 
  647. +                        handle_len ? (handle_len - min_len)    : 0;
  648. +                    fhandle.fh_private_dtor = NULL;
  649. +                    /* 
  650. +                     * if handle_len == 0, 
  651. +                     * FS is expected to give us the handle length it needs. 
  652. +                     */
  653. +                    do_gettimeofday(&begin);
  654. +                    err = f->f_dentry->d_inode->i_op->fill_handle(
  655. +                                f->f_dentry->d_inode, &fhandle);
  656. +                    if (err)
  657. +                        goto drop_filp;
  658. +
  659. +                    /* make sure that FS does not set it to an invalid length */
  660. +                    if (fhandle.fh_private_length <= 0) {
  661. +                        err = -EINVAL;
  662. +                        goto drop_private;
  663. +                    }
  664. +                    
  665. +                    /* try to copy the handle if requested */
  666. +                    if (handle_len > 0) {
  667. +                        __u32 magic, fsid;
  668. +                        struct kstatfs st;
  669. +                        char *key = NULL;
  670. +                        int  keylen = 0, statfs_mask = STATFS_M_TYPE | STATFS_M_FSID;
  671. +                        /*
  672. +                         * Check if fhandle.fh_private was not set.
  673. +                         */
  674. +                        if (fhandle.fh_private == NULL) {
  675. +                            err = -EINVAL;
  676. +                            goto drop_filp;
  677. +                        }
  678. +                        do_gettimeofday(&end);
  679. +                        printk(KERN_DEBUG "fill_handle: took %d usecs\n", diff(&end, &begin));
  680. +                        /*
  681. +                         * Check if the underlying FS wishes to supply a key for 
  682. +                         * the message authentication code.
  683. +                         * If it does not or in case of errors, we use a NULL key
  684. +                         * for the MAC
  685. +                         */
  686. +                        get_fs_key(f->f_dentry->d_inode->i_sb, &key, &keylen);
  687. +                        /* 
  688. +                         * Currently, we issue a statfs on the superblock to figure
  689. +                         * out the magic number and fsid for the file system.
  690. +                         * But this might translate to many network messages for many
  691. +                         * distributed/parallel file systems. Therefore, we need a 
  692. +                         * sb->statfs_lite() callback mechanism to get only those
  693. +                         * fields that don't require a network message.
  694. +                         * If FS does not support the callback, fallback to using statfs.
  695. +                         */
  696. +                        do_gettimeofday(&begin);
  697. +                        if ((err = vfs_statfs_lite(f->f_dentry->d_inode->i_sb, &st, statfs_mask)) < 0) {
  698. +                            //err = vfs_statfs(f->f_dentry->d_inode->i_sb, &st);
  699. +                            //if (err) 
  700. +                                goto drop_private;
  701. +                        }
  702. +                        do_gettimeofday(&end);
  703. +                        printk(KERN_DEBUG "statfs_lite: took %d usecs\n", diff(&end, &begin));
  704. +                        magic = st.f_type;
  705. +                        memcpy(&fsid, &st.f_fsid, sizeof(__u32));
  706. +                        /* set magic number, fsid, flags */
  707. +                        set_fh_field(&fhandle.fh_generic, magic, magic);
  708. +                        set_fh_field(&fhandle.fh_generic, fsid,  fsid);
  709. +                        set_fh_field(&fhandle.fh_generic, flags, flags);
  710. +
  711. +                        do_gettimeofday(&begin);
  712. +                        /* Compute and store crc check sum */
  713. +                        store_crc32_csum(&fhandle);
  714. +                        /* Compute and store HMAC-SHA1 crypto check sum */
  715. +                        store_hmac_csum(&fhandle, key, keylen);
  716. +                        /* copy opaque handle to user buffer */
  717. +                        err = copy_handle(uhandle, &fhandle);
  718. +                        if (err)
  719. +                            goto drop_private;
  720. +                        do_gettimeofday(&end);
  721. +                        printk(KERN_DEBUG "(crc, hmac, copy_handle): took %d usecs\n", diff(&end, &begin));
  722. +                    }
  723. +                    /* update the handle length reported to user-space */
  724. +                    handle_len = fhandle.fh_private_length + min_len;
  725. +                    /* and copy the new length to user space */
  726. +                    err = put_user(handle_len, uhandle_len);
  727. +            drop_private:
  728. +                    drop_file_handle_private(&fhandle);
  729. +                }
  730. +            }
  731. +drop_filp:
  732. +            filp_close(f, NULL);
  733. +        }
  734. +drop_name:
  735. +        putname(tmp);
  736. +    }
  737. +    return err;
  738. +}
  739. +
  740. +asmlinkage long sys_openg(const char __user *pathname, void __user *uhandle, 
  741. +        size_t __user *uhandle_len, int flags, int mode)
  742. +{
  743. +    if (force_o_largefile())
  744. +        flags |= O_LARGEFILE;
  745. +    return do_sys_openg(pathname, uhandle, uhandle_len, flags, mode);
  746. +}
  747. +
  748. +EXPORT_SYMBOL_GPL(sys_openg);
  749. +
  750.  #ifndef __alpha__
  751.  
  752.  /*
  753. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/fs/super.c vanilla-new/fs/super.c
  754. --- vanilla/fs/super.c    2006-03-19 23:53:29.000000000 -0600
  755. +++ vanilla-new/fs/super.c    2006-04-26 22:06:36.000000000 -0500
  756. @@ -799,6 +799,58 @@
  757.  
  758.  EXPORT_SYMBOL(get_sb_single);
  759.  
  760. +struct super_block *get_sb_handle(const struct file_handle *fhandle)
  761. +{
  762. +    /* walk through the list of superblocks */
  763. +    struct super_block *sb;
  764. +
  765. +    spin_lock(&sb_lock);
  766. +    list_for_each_entry (sb, &super_blocks, s_list) {
  767. +        struct kstatfs st;
  768. +
  769. +        sb->s_count++;
  770. +        spin_unlock(&sb_lock);
  771. +        down_read(&sb->s_umount);
  772. +        if (sb->s_root)
  773. +        {
  774. +            int err, statfs_mask = STATFS_M_TYPE | STATFS_M_FSID;
  775. +            /* 
  776. +             * Currently, we issue a statfs on the superblock to figure
  777. +             * out the type and fsid for the file system.
  778. +             * But this might translate to network messages for many
  779. +             * distributed/parallel file systems. Therefore, we need a 
  780. +             * statfs_lite() callback mechanism to get only those
  781. +             * fields that don't require a network message. We fall back to a
  782. +             * regular statfs in case the file system does not support a statfs_lite()
  783. +             * callback.
  784. +             */
  785. +            if ((err = vfs_statfs_lite(sb, &st, statfs_mask)) < 0) {
  786. +                //err = vfs_statfs(sb, &st);
  787. +            }
  788. +            
  789. +            if (err == 0) {
  790. +                __u32 fsid, magic; 
  791. +
  792. +                get_fh_field(&fhandle->fh_generic, fsid, fsid);
  793. +                get_fh_field(&fhandle->fh_generic, magic, magic);
  794. +                /* check if magic numbers and fsid matches */
  795. +                if (st.f_type == magic
  796. +                        && memcmp(&st.f_fsid, &fsid, sizeof(__u32)) == 0)
  797. +                {
  798. +                    return sb;
  799. +                }
  800. +            }
  801. +        }
  802. +        drop_super(sb);
  803. +        spin_lock(&sb_lock);
  804. +    }
  805. +    spin_unlock(&sb_lock);
  806. +    /* This function will not create a new superblock! */
  807. +    return NULL;
  808. +}
  809. +
  810. +EXPORT_SYMBOL_GPL(get_sb_handle);
  811. +
  812.  struct vfsmount *
  813.  do_kern_mount(const char *fstype, int flags, const char *name, void *data)
  814.  {
  815. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/asm-i386/unistd.h vanilla-new/include/asm-i386/unistd.h
  816. --- vanilla/include/asm-i386/unistd.h    2006-03-19 23:53:29.000000000 -0600
  817. +++ vanilla-new/include/asm-i386/unistd.h    2006-04-07 10:28:39.000000000 -0500
  818. @@ -316,8 +316,10 @@
  819.  #define __NR_pselect6        308
  820.  #define __NR_ppoll        309
  821.  #define __NR_unshare        310
  822. +#define __NR_openg      311
  823. +#define __NR_openfh     312
  824.  
  825. -#define NR_syscalls 311
  826. +#define NR_syscalls 313
  827.  
  828.  /*
  829.   * user-visible error numbers are in the range -1 - -128: see
  830. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/asm-ia64/unistd.h vanilla-new/include/asm-ia64/unistd.h
  831. --- vanilla/include/asm-ia64/unistd.h    2006-03-19 23:53:29.000000000 -0600
  832. +++ vanilla-new/include/asm-ia64/unistd.h    2006-04-07 10:28:39.000000000 -0500
  833. @@ -285,12 +285,14 @@
  834.  #define __NR_faccessat            1293
  835.  /* 1294, 1295 reserved for pselect/ppoll */
  836.  #define __NR_unshare            1296
  837. +#define __NR_openg         1297
  838. +#define __NR_openfh        1298
  839.  
  840.  #ifdef __KERNEL__
  841.  
  842.  #include <linux/config.h>
  843.  
  844. -#define NR_syscalls            273 /* length of syscall table */
  845. +#define NR_syscalls            275 /* length of syscall table */
  846.  
  847.  #define __ARCH_WANT_SYS_RT_SIGACTION
  848.  
  849. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/asm-powerpc/unistd.h vanilla-new/include/asm-powerpc/unistd.h
  850. --- vanilla/include/asm-powerpc/unistd.h    2006-03-19 23:53:29.000000000 -0600
  851. +++ vanilla-new/include/asm-powerpc/unistd.h    2006-04-07 10:28:39.000000000 -0500
  852. @@ -301,8 +301,10 @@
  853.  #define __NR_pselect6        280
  854.  #define __NR_ppoll        281
  855.  #define __NR_unshare        282
  856. +#define __NR_openg        283
  857. +#define __NR_openfh        284
  858.  
  859. -#define __NR_syscalls        283
  860. +#define __NR_syscalls        285
  861.  
  862.  #ifdef __KERNEL__
  863.  #define __NR__exit __NR_exit
  864. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/asm-x86_64/unistd.h vanilla-new/include/asm-x86_64/unistd.h
  865. --- vanilla/include/asm-x86_64/unistd.h    2006-03-19 23:53:29.000000000 -0600
  866. +++ vanilla-new/include/asm-x86_64/unistd.h    2006-04-07 10:28:39.000000000 -0500
  867. @@ -605,8 +605,12 @@
  868.  __SYSCALL(__NR_ppoll,    sys_ni_syscall)        /* for now */
  869.  #define __NR_unshare        272
  870.  __SYSCALL(__NR_unshare,    sys_unshare)
  871. +#define __NR_openg      273
  872. +__SYSCALL(__NR_openg,   sys_openg)
  873. +#define __NR_openfh     274
  874. +__SYSCALL(__NR_openfh,  sys_openfh)
  875.  
  876. -#define __NR_syscall_max __NR_unshare
  877. +#define __NR_syscall_max __NR_openfh
  878.  
  879.  #ifndef __NO_STUBS
  880.  
  881. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/linux/fs.h vanilla-new/include/linux/fs.h
  882. --- vanilla/include/linux/fs.h    2006-03-19 23:53:29.000000000 -0600
  883. +++ vanilla-new/include/linux/fs.h    2006-04-17 13:35:37.000000000 -0500
  884. @@ -991,6 +991,27 @@
  885.  #define HAVE_COMPAT_IOCTL 1
  886.  #define HAVE_UNLOCKED_IOCTL 1
  887.  
  888. +struct file_handle_generic {
  889. +    /* Filled by VFS */
  890. +    __le32   fhg_magic; /* magic number */
  891. +    __le32   fhg_fsid; /* file system identifier */
  892. +    __le32   fhg_flags;     /* flags associated with the file object */
  893. +    __le32   fhg_crc_csum; /* crc32c check sum of the blob */
  894. +    __u8     fhg_hmac_sha1[24]; /* hmac-sha1 message authentication code */
  895. +};
  896. +
  897. +struct file_handle {
  898. +    /* generic part filled by VFS */
  899. +    struct file_handle_generic fh_generic;
  900. +    /* FS specific part */
  901. +    void                      *fh_private;
  902. +    size_t                            fh_private_length;
  903. +    void                      (*fh_private_dtor)(void *);
  904. +};
  905. +
  906. +#define set_fh_field(X, Y, Z) (X)->fhg_##Y = cpu_to_le32(Z)
  907. +#define get_fh_field(X, Y, Z) Z = le32_to_cpu((X)->fhg_##Y)
  908. +
  909.  /*
  910.   * NOTE:
  911.   * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
  912. @@ -1049,6 +1070,8 @@
  913.      ssize_t (*listxattr) (struct dentry *, char *, size_t);
  914.      int (*removexattr) (struct dentry *, const char *);
  915.      void (*truncate_range)(struct inode *, loff_t, loff_t);
  916. +    /* method needed for filling up handle */
  917. +    int (*fill_handle)(struct inode *, struct file_handle *);
  918.  };
  919.  
  920.  struct seq_file;
  921. @@ -1065,12 +1088,12 @@
  922.   * without the big kernel lock held in all filesystems.
  923.   */
  924.  struct super_operations {
  925. -       struct inode *(*alloc_inode)(struct super_block *sb);
  926. +   struct inode *(*alloc_inode)(struct super_block *sb);
  927.      void (*destroy_inode)(struct inode *);
  928.  
  929.      void (*read_inode) (struct inode *);
  930.    
  931. -       void (*dirty_inode) (struct inode *);
  932. +      void (*dirty_inode) (struct inode *);
  933.      int (*write_inode) (struct inode *, int);
  934.      void (*put_inode) (struct inode *);
  935.      void (*drop_inode) (struct inode *);
  936. @@ -1081,6 +1104,7 @@
  937.      void (*write_super_lockfs) (struct super_block *);
  938.      void (*unlockfs) (struct super_block *);
  939.      int (*statfs) (struct super_block *, struct kstatfs *);
  940. +    int (*statfs_lite) (struct super_block *, struct kstatfs *, int statfs_mask);
  941.      int (*remount_fs) (struct super_block *, int *, char *);
  942.      void (*clear_inode) (struct inode *);
  943.      void (*umount_begin) (struct super_block *);
  944. @@ -1089,6 +1113,8 @@
  945.  
  946.      ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
  947.      ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
  948. +    struct inode *(*find_inode_handle)(struct super_block *, const struct file_handle *);
  949. +    void    (*get_fs_key)(struct super_block *, char **ppkey, int *keylen);
  950.  };
  951.  
  952.  /* Inode state bits.  Protected by inode_lock. */
  953. @@ -1257,6 +1283,7 @@
  954.  struct super_block *get_sb_nodev(struct file_system_type *fs_type,
  955.      int flags, void *data,
  956.      int (*fill_super)(struct super_block *, void *, int));
  957. +struct super_block *get_sb_handle(const struct file_handle *handle);
  958.  void generic_shutdown_super(struct super_block *sb);
  959.  void kill_block_super(struct super_block *sb);
  960.  void kill_anon_super(struct super_block *sb);
  961. @@ -1292,6 +1319,7 @@
  962.                    struct vfsmount *);
  963.  
  964.  extern int vfs_statfs(struct super_block *, struct kstatfs *);
  965. +extern int vfs_statfs_lite(struct super_block *, struct kstatfs *, int statfs_mask);
  966.  
  967.  /* /sys/fs */
  968.  extern struct subsystem fs_subsys;
  969. @@ -1345,6 +1373,10 @@
  970.                 struct file *filp);
  971.  extern long do_sys_open(int fdf, const char __user *filename, int flags,
  972.              int mode);
  973. +
  974. +extern long do_sys_openfh(const void __user *uhandle, size_t handle_len);
  975. +extern long do_sys_openg(const char __user *pathname, void __user *uhandle, 
  976. +            size_t __user *uhandle_len, int flags, int mode);
  977.  extern struct file *filp_open(const char *, int, int);
  978.  extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
  979.  extern int filp_close(struct file *, fl_owner_t id);
  980. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/linux/limits.h vanilla-new/include/linux/limits.h
  981. --- vanilla/include/linux/limits.h    2006-03-19 23:53:29.000000000 -0600
  982. +++ vanilla-new/include/linux/limits.h    2006-04-07 17:25:07.000000000 -0500
  983. @@ -16,6 +16,7 @@
  984.  #define XATTR_NAME_MAX   255    /* # chars in an extended attribute name */
  985.  #define XATTR_SIZE_MAX 65536    /* size of an extended attribute value (64k) */
  986.  #define XATTR_LIST_MAX 65536    /* size of extended attribute namelist (64k) */
  987. +#define MAX_HANDLE_LEN   128  /* maximum size of a handle used by the openfh system call */
  988.  
  989.  #define RTSIG_MAX      32
  990.  
  991. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/linux/statfs.h vanilla-new/include/linux/statfs.h
  992. --- vanilla/include/linux/statfs.h    2006-03-19 23:53:29.000000000 -0600
  993. +++ vanilla-new/include/linux/statfs.h    2006-04-17 11:38:07.000000000 -0500
  994. @@ -5,6 +5,18 @@
  995.  
  996.  #include <asm/statfs.h>
  997.  
  998. +/* Masks used by statfs_lite callback */
  999. +#define STATFS_M_TYPE          (1 << 0)
  1000. +#define STATFS_M_BSIZE      (1 << 1)
  1001. +#define STATFS_M_BLOCKS        (1 << 2)
  1002. +#define STATFS_M_BFREE      (1 << 3)
  1003. +#define STATFS_M_BAVAIL     (1 << 4)
  1004. +#define STATFS_M_FILES      (1 << 5)
  1005. +#define STATFS_M_FFREE      (1 << 6)
  1006. +#define STATFS_M_FSID       (1 << 7)
  1007. +#define STATFS_M_NAMELEN    (1 << 8)
  1008. +#define STATFS_M_FRSIZE    (1 << 9)
  1009. +
  1010.  struct kstatfs {
  1011.      long f_type;
  1012.      long f_bsize;
  1013. diff -Naur --exclude-from=/home/vilayann/redhat/BUILD/kernel-2.6.16/exclude vanilla/include/linux/syscalls.h vanilla-new/include/linux/syscalls.h
  1014. --- vanilla/include/linux/syscalls.h    2006-03-19 23:53:29.000000000 -0600
  1015. +++ vanilla-new/include/linux/syscalls.h    2006-04-07 13:56:07.000000000 -0500
  1016. @@ -327,6 +327,10 @@
  1017.  asmlinkage long sys_creat(const char __user *pathname, int mode);
  1018.  asmlinkage long sys_open(const char __user *filename,
  1019.                  int flags, int mode);
  1020. +asmlinkage long sys_openfh(const void __user *uhandle, 
  1021. +                size_t handle_len);
  1022. +asmlinkage long sys_openg(const char __user *pathname, void __user *uhandle, 
  1023. +                size_t *uhandle_len, int flags, int mode);
  1024.  asmlinkage long sys_close(unsigned int fd);
  1025.  asmlinkage long sys_access(const char __user *filename, int mode);
  1026.  asmlinkage long sys_vhangup(void);
  1027. @@ -566,7 +570,10 @@
  1028.  asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user * filename,
  1029.                        struct compat_stat __user *statbuf,
  1030.                        int flag);
  1031. +asmlinkage long compat_sys_open(const char __user *filename, int flags, int mode);
  1032.  asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
  1033.                     int flags, int mode);
  1034. -
  1035. +asmlinkage long compat_sys_openg(const char __user *pathname, void __user *uhandle,
  1036. +                    size_t __user *uhandle_len, int flags, int mode);
  1037. +asmlinkage long compat_sys_openfh(const void __user *uhandle, size_t uhandle_len);
  1038.  #endif
  1039.