?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use the -newos toolchain even if -elf is present.
[newos.git] / kernel / addons / fs / nfs / nfs.c
blob42da0802ab5a3e587ed7fef70e7c9b399542547a
1 /*
2 ** Copyright 2002-2006, Travis Geiselbrecht. All rights reserved.
3 ** Distributed under the terms of the NewOS License.
4 */
5 #include <kernel/kernel.h>
6 #include <kernel/vfs.h>
7 #include <kernel/heap.h>
8 #include <kernel/khash.h>
9 #include <kernel/debug.h>
10 #include <kernel/lock.h>
11 #include <kernel/sem.h>
12 #include <kernel/vm.h>
13 #include <kernel/net/misc.h>
14
15 #include <newos/net.h>
16
17 #include <string.h>
18 #include <ctype.h>
19 #include <stdlib.h>
20
21 #include "nfs.h"
22 #include "nfs_fs.h"
23 #include "rpc.h"
24
25 #define NFS_TRACE 0
26
27 #if NFS_TRACE
28 #define TRACE(x...) dprintf(x)
29 #else
30 #define TRACE(x...)
31 #endif
32
33 static int nfs_getattr(nfs_fs *nfs, nfs_vnode *v, uint8 *attrstatbuf, nfs_attrstat *attrstat);
34
35 #if NFS_TRACE
36 static void dump_fhandle(const nfs_fhandle *handle)
37 {
38 unsigned int i;
39
40 for(i=0; i<sizeof(nfs_fhandle); i++)
41 dprintf("%02x", ((const uint8 *)handle)[i]);
42 }
43 #endif
44
45 static nfs_vnode *new_vnode_struct(nfs_fs *fs)
46 {
47 nfs_vnode *v;
48
49 v = (nfs_vnode *)kmalloc(sizeof(nfs_vnode));
50 if(!v)
51 return NULL;
52
53 if (mutex_init(&v->lock, "nfs vnode lock") < 0) {
54 kfree(v);
55 return NULL;
56 }
57
58 v->hash_next = NULL;
59 v->fs = fs;
60
61 return v;
62 }
63
64 static void destroy_vnode_struct(nfs_vnode *v)
65 {
66 mutex_destroy(&v->lock);
67 kfree(v);
68 }
69
70 /* ghetto x.x.x.x:/path parsing code */
71 static int parse_mount(const char *mount, char *address, int address_len, char *server_path, int path_len)
72 {
73 int a, b;
74
75 // trim the beginning
76 for(a = 0; mount[a] != 0 && isspace(mount[a]); a++)
77 ;
78 if(mount[a] == 0)
79 return ERR_NOT_FOUND;
80
81 // search for the ':'
82 for(b = a; mount[b] != 0 && mount[b] != ':'; b++)
83 ;
84 if(mount[b] == 0)
85 return ERR_NOT_FOUND;
86
87 // copy the address out
88 memcpy(address, &mount[a], b - a);
89 address[b - a] = 0;
90
91 // grab the path
92 strcpy(server_path, &mount[b+1]);
93
94 return NO_ERROR;
95 }
96
97 static int nfs_handle_hash_compare(void *a, const void *key)
98 {
99 struct nfs_vnode *v = (struct nfs_vnode *)a;
100 nfs_fhandle *handle = (nfs_fhandle *)key;
101
102 return memcmp(&v->nfs_handle, handle, sizeof(nfs_fhandle));
103 }
104
105 static unsigned int nfs_handle_hash(void *a, const void *key, unsigned int range)
106 {
107 const nfs_fhandle *hashit;
108 unsigned int hash;
109 unsigned int i;
110
111 if (key)
112 hashit = (const nfs_fhandle *)key;
113 else
114 hashit = (const nfs_fhandle *)&((nfs_vnode *)a)->nfs_handle;
115
116 #if NFS_TRACE
117 dprintf("nfs_handle_hash: hashit ");
118 dump_fhandle(hashit);
119 #endif
120
121 hash = 0;
122 for (i=0; i < sizeof(*hashit) / sizeof(unsigned int); i++) {
123 hash += ((unsigned int *)hashit)[i];
124 }
125 hash += hash >> 16;
126
127 hash %= range;
128
129 #if NFS_TRACE
130 dprintf(" hash 0x%x\n", hash);
131 #endif
132
133 return hash;
134 }
135
136 static int nfs_status_to_error(nfs_status status)
137 {
138 switch (status) {
139 case NFS_OK:
140 return NO_ERROR;
141 case NFSERR_PERM:
142 return ERR_PERMISSION_DENIED;
143 case NFSERR_NOENT:
144 return ERR_VFS_PATH_NOT_FOUND;
145 case NFSERR_IO:
146 return ERR_IO_ERROR;
147 case NFSERR_NXIO:
148 return ERR_NOT_FOUND;
149 case NFSERR_ACCES:
150 return ERR_PERMISSION_DENIED;
151 case NFSERR_EXIST:
152 return ERR_VFS_ALREADY_EXISTS;
153 case NFSERR_NODEV:
154 return ERR_NOT_FOUND;
155 case NFSERR_NOTDIR:
156 return ERR_VFS_NOT_DIR;
157 case NFSERR_ISDIR:
158 return ERR_VFS_IS_DIR;
159 case NFSERR_FBIG:
160 return ERR_TOO_BIG;
161 case NFSERR_NOSPC:
162 return ERR_VFS_OUT_OF_SPACE;
163 case NFSERR_ROFS:
164 return ERR_VFS_READONLY_FS;
165 case NFSERR_NAMETOOLONG:
166 return ERR_VFS_PATH_TOO_LONG;
167 case NFSERR_NOTEMPTY:
168 return ERR_VFS_DIR_NOT_EMPTY;
169 case NFSERR_DQUOT:
170 return ERR_VFS_EXCEEDED_QUOTA;
171 case NFSERR_STALE:
172 return ERR_INVALID_HANDLE;
173 default:
174 return ERR_GENERAL;
175 }
176 }
177
178 static int parse_ipv4_addr_str(ipv4_addr *ip_addr, char *ip_addr_string)
179 {
180 int a, b;
181
182 *ip_addr = 0;
183
184 // walk through the first number
185 a = 0;
186 b = 0;
187 for(; ip_addr_string[b] != 0 && ip_addr_string[b] != '.'; b++)
188 ;
189 if(ip_addr_string[b] == 0)
190 return ERR_NOT_FOUND;
191 ip_addr_string[b] = 0;
192 *ip_addr = atoi(&ip_addr_string[a]) << 24;
193 b++;
194
195 // second digit
196 a = b;
197 for(; ip_addr_string[b] != 0 && ip_addr_string[b] != '.'; b++)
198 ;
199 if(ip_addr_string[b] == 0)
200 return ERR_NOT_FOUND;
201 ip_addr_string[b] = 0;
202 *ip_addr |= atoi(&ip_addr_string[a]) << 16;
203 b++;
204
205 // third digit
206 a = b;
207 for(; ip_addr_string[b] != 0 && ip_addr_string[b] != '.'; b++)
208 ;
209 if(ip_addr_string[b] == 0)
210 return ERR_NOT_FOUND;
211 ip_addr_string[b] = 0;
212 *ip_addr |= atoi(&ip_addr_string[a]) << 8;
213 b++;
214
215 // last digit
216 a = b;
217 for(; ip_addr_string[b] != 0 && ip_addr_string[b] != '.'; b++)
218 ;
219 ip_addr_string[b] = 0;
220 *ip_addr |= atoi(&ip_addr_string[a]);
221
222 return NO_ERROR;
223 }
224
225 static int nfs_mount_fs(nfs_fs *nfs, const char *server_path)
226 {
227 uint8 sendbuf[256];
228 char buf[128];
229 nfs_mountargs args;
230 size_t arglen;
231 int err;
232
233 rpc_set_port(&nfs->rpc, nfs->mount_port);
234
235 args.dirpath = server_path;
236 arglen = nfs_pack_mountargs(sendbuf, &args);
237
238 err = rpc_call(&nfs->rpc, MOUNTPROG, MOUNTVERS, MOUNTPROC_MNT, sendbuf, arglen, buf, sizeof(buf));
239 if(err < 0)
240 return err;
241
242 #if NFS_TRACE
243 TRACE("nfs_mount_fs: have root fhandle: ");
244 dump_fhandle((const nfs_fhandle *)&buf[4]);
245 TRACE("\n");
246 #endif
247 // we should have the root handle now
248 memcpy(&nfs->root_vnode->nfs_handle, &buf[4], sizeof(nfs->root_vnode->nfs_handle));
249
250 // set the rpc port to the nfs server
251 rpc_set_port(&nfs->rpc, nfs->nfs_port);
252
253 return 0;
254 }
255
256 static int nfs_unmount_fs(nfs_fs *nfs)
257 {
258 uint8 sendbuf[256];
259 size_t arglen;
260 nfs_mountargs args;
261 int err;
262
263 rpc_set_port(&nfs->rpc, nfs->mount_port);
264
265 args.dirpath = nfs->server_path;
266 arglen = nfs_pack_mountargs(sendbuf, &args);
267
268 err = rpc_call(&nfs->rpc, MOUNTPROG, MOUNTVERS, MOUNTPROC_UMNT, sendbuf, arglen, NULL, 0);
269
270 return err;
271 }
272
273 int nfs_mount(fs_cookie *fs, fs_id id, const char *device, void *args, vnode_id *root_vnid)
274 {
275 nfs_fs *nfs;
276 int err;
277 char ip_addr_str[128];
278 ipv4_addr ip_addr;
279
280 TRACE("nfs_mount: fsid 0x%x, device '%s'\n", id, device);
281
282 /* create the fs structure */
283 nfs = kmalloc(sizeof(nfs_fs));
284 if(!nfs) {
285 err = ERR_NO_MEMORY;
286 goto err;
287 }
288 memset(nfs, 0, sizeof(nfs_fs));
289
290 mutex_init(&nfs->lock, "nfs lock");
291
292 err = parse_mount(device, ip_addr_str, sizeof(ip_addr_str), nfs->server_path, sizeof(nfs->server_path));
293 if(err < 0) {
294 err = ERR_NET_BAD_ADDRESS;
295 goto err1;
296 }
297
298 err = parse_ipv4_addr_str(&ip_addr, ip_addr_str);
299 if(err < 0) {
300 err = ERR_NET_BAD_ADDRESS;
301 goto err1;
302 }
303
304 nfs->id = id;
305 nfs->server_addr.type = ADDR_TYPE_IP;
306 nfs->server_addr.len = 4;
307 NETADDR_TO_IPV4(nfs->server_addr) = ip_addr;
308
309 // set up the rpc state
310 rpc_init_state(&nfs->rpc);
311 rpc_open_socket(&nfs->rpc, &nfs->server_addr);
312
313 // look up the port numbers for mount and nfs
314 rpc_pmap_lookup(&nfs->server_addr, MOUNTPROG, MOUNTVERS, IP_PROT_UDP, &nfs->mount_port);
315 rpc_pmap_lookup(&nfs->server_addr, NFSPROG, NFSVERS, IP_PROT_UDP, &nfs->nfs_port);
316
317 nfs->root_vnode = new_vnode_struct(nfs);
318 nfs->root_vnode->st = STREAM_TYPE_DIR;
319
320 // try to mount the filesystem
321 err = nfs_mount_fs(nfs, nfs->server_path);
322 if(err < 0)
323 goto err2;
324
325 // build the vnode hash table and stick the root vnode in it
326 nfs->handle_hash = hash_init(1024, offsetof(struct nfs_vnode, hash_next),
327 nfs_handle_hash_compare,
328 nfs_handle_hash);
329 if (!nfs->handle_hash) {
330 err = ERR_NO_MEMORY;
331 goto err2;
332 }
333 hash_insert(nfs->handle_hash, nfs->root_vnode);
334
335 *fs = nfs;
336 *root_vnid = VNODETOVNID(nfs->root_vnode);
337
338 return 0;
339
340 err2:
341 destroy_vnode_struct(nfs->root_vnode);
342 rpc_destroy_state(&nfs->rpc);
343 err1:
344 mutex_destroy(&nfs->lock);
345 kfree(nfs);
346 err:
347 return err;
348 }
349
350 int nfs_unmount(fs_cookie fs)
351 {
352 nfs_fs *nfs = (nfs_fs *)fs;
353
354 TRACE("nfs_unmount: fsid 0x%x\n", nfs->id);
355
356 // put_vnode on the root to release the ref to it
357 vfs_put_vnode(nfs->id, VNODETOVNID(nfs->root_vnode));
358
359 nfs_unmount_fs(nfs);
360
361 hash_uninit(nfs->handle_hash);
362
363 rpc_destroy_state(&nfs->rpc);
364
365 mutex_destroy(&nfs->lock);
366 kfree(nfs);
367
368 return 0;
369 }
370
371 int nfs_sync(fs_cookie fs)
372 {
373 nfs_fs *nfs = (nfs_fs *)fs;
374
375 TOUCH(nfs);
376
377 TRACE("nfs_sync: fsid 0x%x\n", nfs->id);
378 return 0;
379 }
380
381 int nfs_lookup(fs_cookie fs, fs_vnode _dir, const char *name, vnode_id *id)
382 {
383 nfs_fs *nfs = (nfs_fs *)fs;
384 nfs_vnode *dir = (nfs_vnode *)_dir;
385 int err;
386
387 TRACE("nfs_lookup: fsid 0x%x, dirvnid 0x%Lx, name '%s'\n", nfs->id, VNODETOVNID(dir), name);
388
389 mutex_lock(&dir->lock);
390
391 {
392 uint8 sendbuf[NFS_DIROPARGS_MAXLEN];
393 nfs_diropargs args;
394 size_t arglen;
395
396 uint8 resbuf[NFS_DIROPRES_MAXLEN];
397 nfs_diropres res;
398
399 /* set up the args structure */
400 args.dir = &dir->nfs_handle;
401 args.name.name = name;
402 arglen = nfs_pack_diropargs(sendbuf, &args);
403
404 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, NFSPROC_LOOKUP, sendbuf, arglen, resbuf, sizeof(resbuf));
405 if(err < 0) {
406 err = ERR_NOT_FOUND;
407 goto out;
408 }
409
410 nfs_unpack_diropres(resbuf, &res);
411
412 /* see if the lookup was successful */
413 if(res.status == NFS_OK) {
414 nfs_vnode *v;
415 nfs_vnode *v2;
416 bool newvnode;
417
418 /* successful lookup */
419 #if NFS_TRACE
420 dprintf("nfs_lookup: result of lookup of '%s'\n", name);
421 dprintf("\tfhandle: "); dump_fhandle(res.file); dprintf("\n");
422 dprintf("\tsize: %d\n", res.attributes->size);
423 nfs_handle_hash(NULL, res.file, 1024);
424 #endif
425
426 /* see if the vnode already exists */
427 newvnode = false;
428 v = hash_lookup(nfs->handle_hash, res.file);
429 if (v == NULL) {
430 /* didn't find it, create a new one */
431 v = new_vnode_struct(nfs);
432 if(v == NULL) {
433 err = ERR_NO_MEMORY;
434 goto out;
435 }
436
437 /* copy the file handle over */
438 memcpy(&v->nfs_handle, res.file, sizeof(v->nfs_handle));
439
440 /* figure out the stream type from the return value and cache it */
441 switch(res.attributes->ftype) {
442 case NFREG:
443 v->st = STREAM_TYPE_FILE;
444 break;
445 case NFDIR:
446 v->st = STREAM_TYPE_DIR;
447 break;
448 default:
449 v->st = -1;
450 }
451
452 /* add it to the handle -> vnode lookup table */
453 mutex_lock(&nfs->lock);
454 hash_insert(nfs->handle_hash, v);
455 mutex_unlock(&nfs->lock);
456 newvnode = true;
457 }
458
459 /* request that the vfs layer look it up */
460 err = vfs_get_vnode(nfs->id, VNODETOVNID(v), (fs_vnode *)(void *)&v2);
461 if(err < 0) {
462 if (newvnode) {
463 mutex_lock(&nfs->lock);
464 hash_remove(nfs->handle_hash, v);
465 mutex_unlock(&nfs->lock);
466 destroy_vnode_struct(v);
467 }
468 err = ERR_NOT_FOUND;
469 goto out;
470 }
471
472 ASSERT(v == v2);
473
474 *id = VNODETOVNID(v);
475 } else {
476 TRACE("nfs_lookup: '%s' not found\n", name);
477 err = ERR_NOT_FOUND;
478 goto out;
479 }
480 }
481
482 err = NO_ERROR;
483
484 out:
485 mutex_unlock(&dir->lock);
486
487 return err;
488 }
489
490 int nfs_getvnode(fs_cookie fs, vnode_id id, fs_vnode *v, bool r)
491 {
492 nfs_fs *nfs = (nfs_fs *)fs;
493
494 TOUCH(nfs);
495
496 TRACE("nfs_getvnode: fsid 0x%x, vnid 0x%Lx\n", nfs->id, id);
497
498 *v = VNIDTOVNODE(id);
499
500 return NO_ERROR;
501 }
502
503 int nfs_putvnode(fs_cookie fs, fs_vnode _v, bool r)
504 {
505 nfs_fs *nfs = (nfs_fs *)fs;
506 nfs_vnode *v = (nfs_vnode *)_v;
507
508 TOUCH(nfs);
509
510 TRACE("nfs_putvnode: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
511
512 mutex_lock(&nfs->lock);
513 hash_remove(nfs->handle_hash, v);
514 mutex_unlock(&nfs->lock);
515 destroy_vnode_struct(v);
516
517 return NO_ERROR;
518 }
519
520 int nfs_removevnode(fs_cookie fs, fs_vnode _v, bool r)
521 {
522 nfs_fs *nfs = (nfs_fs *)fs;
523 nfs_vnode *v = (nfs_vnode *)_v;
524
525 TOUCH(nfs);TOUCH(v);
526
527 TRACE("nfs_removevnode: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
528
529 return ERR_UNIMPLEMENTED;
530 }
531
532 static int nfs_opendir(fs_cookie _fs, fs_vnode _v, dir_cookie *_cookie)
533 {
534 struct nfs_vnode *v = (struct nfs_vnode *)_v;
535 struct nfs_cookie *cookie;
536 int err = 0;
537
538 TRACE("nfs_opendir: vnode %p\n", v);
539
540 if(v->st != STREAM_TYPE_DIR)
541 return ERR_VFS_NOT_DIR;
542
543 cookie = kmalloc(sizeof(struct nfs_cookie));
544 if(cookie == NULL)
545 return ERR_NO_MEMORY;
546
547 cookie->v = v;
548 cookie->u.dir.nfscookie = 0;
549 cookie->u.dir.at_end = false;
550
551 *_cookie = cookie;
552
553 return err;
554 }
555
556 static int nfs_closedir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie)
557 {
558 struct nfs_fs *fs = _fs;
559 struct nfs_vnode *v = _v;
560 struct nfs_cookie *cookie = _cookie;
561
562 TOUCH(fs);TOUCH(v);TOUCH(cookie);
563
564 TRACE("nfs_closedir: entry vnode %p, cookie %p\n", v, cookie);
565
566 if(v->st != STREAM_TYPE_DIR)
567 return ERR_VFS_NOT_DIR;
568
569 if(cookie)
570 kfree(cookie);
571
572 return 0;
573 }
574
575 static int nfs_rewinddir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie)
576 {
577 struct nfs_vnode *v = _v;
578 struct nfs_cookie *cookie = _cookie;
579 int err = 0;
580
581 TOUCH(v);
582
583 TRACE("nfs_rewinddir: vnode %p, cookie %p\n", v, cookie);
584
585 if(v->st != STREAM_TYPE_DIR)
586 return ERR_VFS_NOT_DIR;
587
588 mutex_lock(&v->lock);
589
590 cookie->u.dir.nfscookie = 0;
591 cookie->u.dir.at_end = false;
592
593 mutex_unlock(&v->lock);
594
595 return err;
596 }
597
598 #define READDIR_BUF_SIZE (MAXNAMLEN + 64)
599
600 static ssize_t _nfs_readdir(nfs_fs *nfs, nfs_vnode *v, nfs_cookie *cookie, void *buf, ssize_t len)
601 {
602 uint8 resbuf[READDIR_BUF_SIZE];
603 nfs_readdirres *res = (nfs_readdirres *)resbuf;
604 uint8 argbuf[NFS_READDIRARGS_MAXLEN];
605 nfs_readdirargs args;
606 size_t arglen;
607 ssize_t err = 0;
608 int i;
609 int namelen;
610
611 if(len < MAXNAMLEN)
612 return ERR_VFS_INSUFFICIENT_BUF; // XXX not quite accurate
613
614 /* see if we've already hit the end */
615 if(cookie->u.dir.at_end)
616 return 0;
617
618 /* put together the message */
619 args.dir = &v->nfs_handle;
620 args.cookie = cookie->u.dir.nfscookie;
621 args.count = min(len, READDIR_BUF_SIZE);
622 arglen = nfs_pack_readdirargs(argbuf, &args);
623
624 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, NFSPROC_READDIR, argbuf, arglen, resbuf, sizeof(resbuf));
625 if(err < 0)
626 return err;
627
628 /* get response */
629 if(ntohl(res->status) != NFS_OK)
630 return 0;
631
632 /* walk into the buffer, looking for the first entry */
633 if(ntohl(res->data[0]) == 0) {
634 // end of list
635 cookie->u.dir.at_end = true;
636 return 0;
637 }
638 i = ntohl(res->data[0]);
639
640 /* copy the data out of the first entry */
641 strlcpy(buf, (char const *)&res->data[i + 2], ntohl(res->data[i + 1]) + 1);
642
643 namelen = ROUNDUP(ntohl(res->data[i + 1]), 4);
644
645 /* update the cookie */
646 cookie->u.dir.nfscookie = res->data[i + namelen / 4 + 2];
647
648 return ntohl(res->data[i + 1]);
649 }
650
651 static int nfs_readdir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie, void *buf, size_t len)
652 {
653 struct nfs_fs *fs = _fs;
654 struct nfs_vnode *v = _v;
655 struct nfs_cookie *cookie = _cookie;
656 int err = 0;
657
658 TOUCH(v);
659
660 TRACE("nfs_readdir: vnode %p, cookie %p, len 0x%x\n", v, cookie, len);
661
662 if(v->st != STREAM_TYPE_DIR)
663 return ERR_VFS_NOT_DIR;
664
665 mutex_lock(&v->lock);
666
667 err = _nfs_readdir(fs, v, cookie, buf, len);
668
669 mutex_unlock(&v->lock);
670
671 return err;
672 }
673
674 int nfs_open(fs_cookie fs, fs_vnode _v, file_cookie *_cookie, int oflags)
675 {
676 nfs_fs *nfs = (nfs_fs *)fs;
677 nfs_vnode *v = (nfs_vnode *)_v;
678 nfs_cookie *cookie;
679 int err;
680
681 TOUCH(nfs);
682
683 TRACE("nfs_open: fsid 0x%x, vnid 0x%Lx, oflags 0x%x\n", nfs->id, VNODETOVNID(v), oflags);
684
685 if(v->st == STREAM_TYPE_DIR) {
686 err = ERR_VFS_IS_DIR;
687 goto err;
688 }
689
690 cookie = kmalloc(sizeof(nfs_cookie));
691 if(cookie == NULL) {
692 err = ERR_NO_MEMORY;
693 goto err;
694 }
695 cookie->v = v;
696
697 cookie->u.file.pos = 0;
698 cookie->u.file.oflags = oflags;
699
700 *_cookie = (file_cookie)cookie;
701 err = NO_ERROR;
702
703 err:
704 return err;
705 }
706
707 int nfs_close(fs_cookie fs, fs_vnode _v, file_cookie _cookie)
708 {
709 nfs_fs *nfs = (nfs_fs *)fs;
710 nfs_vnode *v = (nfs_vnode *)_v;
711
712 TOUCH(nfs);TOUCH(v);
713
714 TRACE("nfs_close: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
715
716 if(v->st == STREAM_TYPE_DIR)
717 return ERR_VFS_IS_DIR;
718
719 return NO_ERROR;
720 }
721
722 int nfs_freecookie(fs_cookie fs, fs_vnode _v, file_cookie _cookie)
723 {
724 nfs_fs *nfs = (nfs_fs *)fs;
725 nfs_vnode *v = (nfs_vnode *)_v;
726 nfs_cookie *cookie = (nfs_cookie *)_cookie;
727
728 TOUCH(nfs);TOUCH(v);
729
730 TRACE("nfs_freecookie: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
731
732 if(v->st == STREAM_TYPE_DIR)
733 return ERR_VFS_IS_DIR;
734
735 kfree(cookie);
736
737 return NO_ERROR;
738 }
739
740 int nfs_fsync(fs_cookie fs, fs_vnode _v)
741 {
742 nfs_fs *nfs = (nfs_fs *)fs;
743 nfs_vnode *v = (nfs_vnode *)_v;
744
745 TOUCH(nfs);TOUCH(v);
746
747 TRACE("nfs_fsync: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
748
749 return NO_ERROR;
750 }
751
752 #define READ_BUF_SIZE 1024
753
754 static ssize_t nfs_readfile(nfs_fs *nfs, nfs_vnode *v, nfs_cookie *cookie, void *buf, off_t pos, ssize_t len, bool updatecookiepos)
755 {
756 uint8 resbuf[NFS_READRES_MAXLEN + READ_BUF_SIZE];
757 nfs_readres res;
758
759 uint8 argbuf[NFS_READARGS_MAXLEN];
760 nfs_readargs args;
761 size_t arglen;
762 int err;
763 ssize_t total_read = 0;
764
765 TRACE("nfs_readfile: v %p, buf %p, pos %Ld, len %d\n", v, buf, pos, len);
766
767 /* check args */
768 if(pos < 0)
769 pos = cookie->u.file.pos;
770 /* can't do more than 32-bit offsets right now */
771 if(pos > 0xffffffff)
772 return 0;
773 /* negative or zero length means nothing */
774 if(len <= 0)
775 return 0;
776
777 while(len > 0) {
778 ssize_t to_read = min(len, READ_BUF_SIZE);
779
780 /* put together the message */
781 args.file = &v->nfs_handle;
782 args.offset = pos;
783 args.count = to_read;
784 args.totalcount = 0; // unused
785 arglen = nfs_pack_readargs(argbuf, &args);
786
787 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, NFSPROC_READ, argbuf, arglen, resbuf, sizeof(resbuf));
788 if(err < 0)
789 break;
790
791 nfs_unpack_readres(resbuf, &res);
792
793 /* get response */
794 if(res.status != NFS_OK)
795 break;
796
797 /* see how much we read */
798 err = user_memcpy((uint8 *)buf + total_read, res.data, res.len);
799 if(err < 0) {
800 total_read = err; // bad user give me bad buffer
801 break;
802 }
803
804 pos += res.len;
805 len -= res.len;
806 total_read += res.len;
807
808 /* short read, we're done */
809 if((ssize_t)res.len != to_read)
810 break;
811 }
812
813 if (updatecookiepos)
814 cookie->u.file.pos = pos;
815
816 return total_read;
817 }
818
819 ssize_t nfs_read(fs_cookie fs, fs_vnode _v, file_cookie _cookie, void *buf, off_t pos, ssize_t len)
820 {
821 nfs_fs *nfs = (nfs_fs *)fs;
822 nfs_vnode *v = (nfs_vnode *)_v;
823 nfs_cookie *cookie = (nfs_cookie *)_cookie;
824 ssize_t err;
825
826 TRACE("nfs_read: fsid 0x%x, vnid 0x%Lx, buf %p, pos 0x%Lx, len %ld\n", nfs->id, VNODETOVNID(v), buf, pos, len);
827
828 if(v->st == STREAM_TYPE_DIR)
829 return ERR_VFS_IS_DIR;
830
831 mutex_lock(&v->lock);
832
833 err = nfs_readfile(nfs, v, cookie, buf, pos, len, true);
834
835 mutex_unlock(&v->lock);
836
837 return err;
838 }
839
840 #define WRITE_BUF_SIZE 1024
841
842 static ssize_t nfs_writefile(nfs_fs *nfs, nfs_vnode *v, nfs_cookie *cookie, const void *buf, off_t pos, ssize_t len, bool updatecookiepos)
843 {
844 #if 0
845 uint8 abuf[sizeof(nfs_writeargs) + WRITE_BUF_SIZE];
846 nfs_writeargs *args = (nfs_writeargs *)abuf;
847 nfs_attrstat *res = (nfs_attrstat *)abuf;
848 int err;
849 ssize_t total_written = 0;
850
851 /* check args */
852 if(pos < 0)
853 pos = cookie->u.file.pos;
854 /* can't do more than 32-bit offsets right now */
855 if(pos > 0xffffffff)
856 return 0;
857 /* negative or zero length means nothing */
858 if(len <= 0)
859 return 0;
860
861 while(len > 0) {
862 ssize_t to_write = min(len, WRITE_BUF_SIZE);
863
864 /* put together the message */
865 memcpy(&args->file, &v->nfs_handle, sizeof(args->file));
866 args->beginoffset = 0; // unused
867 args->offset = htonl(pos);
868 args->totalcount = htonl(to_write);
869 err = user_memcpy(args->data, (const uint8 *)buf + total_written, to_write);
870 if(err < 0) {
871 total_written = err;
872 break;
873 }
874
875 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, NFSPROC_WRITE, args, sizeof(*args) + to_write, abuf, sizeof(abuf));
876 if(err < 0)
877 break;
878
879 /* get response */
880 if(ntohl(res->status) != NFS_OK)
881 break;
882
883 pos += to_write;
884 len -= to_write;
885 total_written += to_write;
886 }
887
888 if (updatecookiepos)
889 cookie->u.file.pos = pos;
890
891 return total_written;
892 #endif
893 return ERR_UNIMPLEMENTED;
894 }
895
896 ssize_t nfs_write(fs_cookie fs, fs_vnode _v, file_cookie _cookie, const void *buf, off_t pos, ssize_t len)
897 {
898 nfs_fs *nfs = (nfs_fs *)fs;
899 nfs_vnode *v = (nfs_vnode *)_v;
900 nfs_cookie *cookie = (nfs_cookie *)_cookie;
901 ssize_t err;
902
903 TRACE("nfs_write: fsid 0x%x, vnid 0x%Lx, buf %p, pos 0x%Lx, len %ld\n", nfs->id, VNODETOVNID(v), buf, pos, len);
904
905 mutex_lock(&v->lock);
906
907 switch(v->st) {
908 case STREAM_TYPE_FILE:
909 err = nfs_writefile(nfs, v, cookie, buf, pos, len, true);
910 break;
911 case STREAM_TYPE_DIR:
912 err = ERR_NOT_ALLOWED;
913 break;
914 default:
915 err = ERR_GENERAL;
916 }
917
918 mutex_unlock(&v->lock);
919
920 return err;
921 }
922
923 int nfs_seek(fs_cookie fs, fs_vnode _v, file_cookie _cookie, off_t pos, seek_type st)
924 {
925 nfs_fs *nfs = (nfs_fs *)fs;
926 nfs_vnode *v = (nfs_vnode *)_v;
927 nfs_cookie *cookie = (nfs_cookie *)_cookie;
928 int err = NO_ERROR;
929 uint8 attrstatbuf[NFS_ATTRSTAT_MAXLEN];
930 nfs_attrstat attrstat;
931 off_t file_len;
932
933 TRACE("nfs_seek: fsid 0x%x, vnid 0x%Lx, pos 0x%Lx, seek_type %d\n", nfs->id, VNODETOVNID(v), pos, st);
934
935 if(v->st == STREAM_TYPE_DIR)
936 return ERR_VFS_IS_DIR;
937
938 mutex_lock(&v->lock);
939
940 err = nfs_getattr(nfs, v, attrstatbuf, &attrstat);
941 if(err < 0)
942 goto out;
943
944 file_len = attrstat.attributes->size;
945
946 switch(st) {
947 case _SEEK_SET:
948 if(pos < 0)
949 pos = 0;
950 if(pos > file_len)
951 pos = file_len;
952 cookie->u.file.pos = pos;
953 break;
954 case _SEEK_CUR:
955 if(pos + cookie->u.file.pos > file_len)
956 cookie->u.file.pos = file_len;
957 else if(pos + cookie->u.file.pos < 0)
958 cookie->u.file.pos = 0;
959 else
960 cookie->u.file.pos += pos;
961 break;
962 case _SEEK_END:
963 if(pos > 0)
964 cookie->u.file.pos = file_len;
965 else if(pos + file_len < 0)
966 cookie->u.file.pos = 0;
967 else
968 cookie->u.file.pos = pos + file_len;
969 break;
970 default:
971 err = ERR_INVALID_ARGS;
972 }
973
974 out:
975 mutex_unlock(&v->lock);
976
977 return err;
978 }
979
980 int nfs_ioctl(fs_cookie fs, fs_vnode _v, file_cookie cookie, int op, void *buf, size_t len)
981 {
982 nfs_fs *nfs = (nfs_fs *)fs;
983 nfs_vnode *v = (nfs_vnode *)_v;
984
985 TOUCH(nfs);TOUCH(v);
986
987 TRACE("nfs_ioctl: fsid 0x%x, vnid 0x%Lx, op %d, buf %p, len %ld\n", nfs->id, VNODETOVNID(v), op, buf, len);
988
989 return ERR_UNIMPLEMENTED;
990 }
991
992 int nfs_canpage(fs_cookie fs, fs_vnode _v)
993 {
994 nfs_fs *nfs = (nfs_fs *)fs;
995 nfs_vnode *v = (nfs_vnode *)_v;
996
997 TOUCH(nfs);TOUCH(v);
998
999 TRACE("nfs_canpage: fsid 0x%x, vnid 0x%Lx\n", nfs->id, VNODETOVNID(v));
1000
1001 if(v->st == STREAM_TYPE_FILE)
1002 return 1;
1003 else
1004 return 0;
1005 }
1006
1007 ssize_t nfs_readpage(fs_cookie fs, fs_vnode _v, iovecs *vecs, off_t pos)
1008 {
1009 nfs_fs *nfs = (nfs_fs *)fs;
1010 nfs_vnode *v = (nfs_vnode *)_v;
1011 unsigned int i;
1012 ssize_t readfile_return;
1013 ssize_t total_bytes_read = 0;
1014
1015 TOUCH(nfs);TOUCH(v);
1016
1017 TRACE("nfs_readpage: fsid 0x%x, vnid 0x%Lx, vecs %p, pos 0x%Lx\n", nfs->id, VNODETOVNID(v), vecs, pos);
1018
1019 if(v->st == STREAM_TYPE_DIR)
1020 return ERR_VFS_IS_DIR;
1021
1022 mutex_lock(&v->lock);
1023
1024 for (i=0; i < vecs->num; i++) {
1025 readfile_return = nfs_readfile(nfs, v, NULL, vecs->vec[i].start, pos, vecs->vec[i].len, false);
1026 TRACE("nfs_readpage: nfs_readfile returns %d\n", readfile_return);
1027 if (readfile_return < 0)
1028 goto out;
1029
1030 pos += readfile_return;
1031 total_bytes_read += readfile_return;
1032
1033 if ((size_t)readfile_return < vecs->vec[i].len) {
1034 /* we have hit the end of file, zero out the rest */
1035 for (; i < vecs->num; i++) {
1036 memset(vecs->vec[i].start + readfile_return, 0, vecs->vec[i].len - readfile_return);
1037 total_bytes_read += vecs->vec[i].len - readfile_return;
1038
1039 readfile_return = 0; // after the first pass, wipe out entire pages
1040 }
1041 }
1042 }
1043
1044 out:
1045 mutex_unlock(&v->lock);
1046
1047 return total_bytes_read;
1048 }
1049
1050 ssize_t nfs_writepage(fs_cookie fs, fs_vnode _v, iovecs *vecs, off_t pos)
1051 {
1052 nfs_fs *nfs = (nfs_fs *)fs;
1053 nfs_vnode *v = (nfs_vnode *)_v;
1054
1055 TOUCH(nfs);TOUCH(v);
1056
1057 TRACE("nfs_writepage: fsid 0x%x, vnid 0x%Lx, vecs %p, pos 0x%Lx\n", nfs->id, VNODETOVNID(v), vecs, pos);
1058
1059 if(v->st == STREAM_TYPE_DIR)
1060 return ERR_VFS_IS_DIR;
1061
1062 return ERR_UNIMPLEMENTED;
1063 }
1064
1065 static int _nfs_create(nfs_fs *nfs, nfs_vnode *dir, const char *name, stream_type type, vnode_id *new_vnid)
1066 {
1067 int err;
1068 uint8 argbuf[NFS_CREATEARGS_MAXLEN];
1069 nfs_createargs args;
1070 size_t arglen;
1071 uint8 resbuf[NFS_DIROPRES_MAXLEN];
1072 nfs_diropres res;
1073 nfs_vnode *v, *v2;
1074 int proc;
1075
1076 /* start building the args */
1077 args.where.dir = &dir->nfs_handle;
1078 args.where.name.name = name;
1079 args.attributes.mode = 0777;
1080 args.attributes.uid = 0;
1081 args.attributes.gid = 0;
1082 args.attributes.size = 0;
1083 args.attributes.atime.seconds = 0;
1084 args.attributes.atime.useconds = 0;
1085 args.attributes.mtime.seconds = 0;
1086 args.attributes.mtime.useconds = 0;
1087 arglen = nfs_pack_createopargs(argbuf, &args);
1088
1089 switch (type) {
1090 case STREAM_TYPE_FILE:
1091 proc = NFSPROC_CREATE;
1092 break;
1093 case STREAM_TYPE_DIR:
1094 proc = NFSPROC_MKDIR;
1095 break;
1096 default:
1097 panic("_nfs_create asked to make file type it doesn't understand\n");
1098 }
1099
1100 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, proc, argbuf, arglen, resbuf, sizeof(resbuf));
1101 if (err < 0)
1102 return err;
1103
1104 nfs_unpack_diropres(resbuf, &res);
1105
1106 if (res.status != NFS_OK) {
1107 err = nfs_status_to_error(res.status);
1108 goto err;
1109 }
1110
1111 /* if new_vnid is null, the layers above us aren't requesting that we bring the vnode into existence */
1112 if (new_vnid == NULL) {
1113 err = 0;
1114 goto out;
1115 }
1116
1117 /* create a new vnode */
1118 v = new_vnode_struct(nfs);
1119 if (v == NULL) {
1120 err = ERR_NO_MEMORY;
1121 /* weird state here. we've created a file but failed */
1122 goto err;
1123 }
1124
1125 /* copy the file handle over */
1126 memcpy(&v->nfs_handle, res.file, sizeof(v->nfs_handle));
1127
1128 /* figure out the stream type from the return value and cache it */
1129 switch (res.attributes->ftype) {
1130 case NFREG:
1131 v->st = STREAM_TYPE_FILE;
1132 break;
1133 case NFDIR:
1134 v->st = STREAM_TYPE_DIR;
1135 break;
1136 default:
1137 v->st = -1;
1138 }
1139
1140 /* add it to the handle -> vnode lookup table */
1141 mutex_lock(&nfs->lock);
1142 hash_insert(nfs->handle_hash, v);
1143 mutex_unlock(&nfs->lock);
1144
1145 /* request that the vfs layer look it up */
1146 err = vfs_get_vnode(nfs->id, VNODETOVNID(v), (fs_vnode *)(void *)&v2);
1147 if (err < 0) {
1148 mutex_lock(&nfs->lock);
1149 hash_remove(nfs->handle_hash, v);
1150 mutex_unlock(&nfs->lock);
1151 destroy_vnode_struct(v);
1152 err = ERR_NOT_FOUND;
1153 goto err;
1154 }
1155
1156 *new_vnid = VNODETOVNID(v);
1157
1158 err = 0;
1159
1160 out:
1161 err:
1162 return err;
1163 }
1164
1165 int nfs_create(fs_cookie fs, fs_vnode _dir, const char *name, void *create_args, vnode_id *new_vnid)
1166 {
1167 nfs_fs *nfs = (nfs_fs *)fs;
1168 nfs_vnode *dir = (nfs_vnode *)_dir;
1169 int err;
1170
1171 TOUCH(nfs);TOUCH(dir);
1172
1173 TRACE("nfs_create: fsid 0x%x, vnid 0x%Lx, name '%s'\n", nfs->id, VNODETOVNID(dir), name);
1174
1175 mutex_lock(&dir->lock);
1176
1177 err = _nfs_create(nfs, dir, name, STREAM_TYPE_FILE, new_vnid);
1178
1179 mutex_unlock(&dir->lock);
1180
1181 return err;
1182 }
1183
1184 static int _nfs_unlink(nfs_fs *nfs, nfs_vnode *dir, const char *name, stream_type type)
1185 {
1186 int err;
1187 uint8 argbuf[NFS_DIROPARGS_MAXLEN];
1188 nfs_diropargs args;
1189 size_t arglen;
1190 nfs_status res;
1191 int proc;
1192
1193 /* start building the args */
1194 args.dir = &dir->nfs_handle;
1195 args.name.name = name;
1196 arglen = nfs_pack_diropargs(argbuf, &args);
1197
1198 switch (type) {
1199 case STREAM_TYPE_FILE:
1200 proc = NFSPROC_REMOVE;
1201 break;
1202 case STREAM_TYPE_DIR:
1203 proc = NFSPROC_RMDIR;
1204 break;
1205 default:
1206 panic("_nfs_unlink asked to remove file type it doesn't understand\n");
1207 }
1208
1209 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, proc, argbuf, arglen, &res, sizeof(res));
1210 if (err < 0)
1211 return err;
1212
1213 return nfs_status_to_error(ntohl(res));
1214 }
1215
1216 int nfs_unlink(fs_cookie fs, fs_vnode _dir, const char *name)
1217 {
1218 nfs_fs *nfs = (nfs_fs *)fs;
1219 nfs_vnode *dir = (nfs_vnode *)_dir;
1220 int err;
1221
1222 TOUCH(nfs);TOUCH(dir);
1223
1224 TRACE("nfs_unlink: fsid 0x%x, vnid 0x%Lx, name '%s'\n", nfs->id, VNODETOVNID(dir), name);
1225
1226 mutex_lock(&dir->lock);
1227
1228 err = _nfs_unlink(nfs, dir, name, STREAM_TYPE_FILE);
1229
1230 mutex_unlock(&dir->lock);
1231
1232 return err;
1233 }
1234
1235 int nfs_rename(fs_cookie fs, fs_vnode _olddir, const char *oldname, fs_vnode _newdir, const char *newname)
1236 {
1237 nfs_fs *nfs = (nfs_fs *)fs;
1238 nfs_vnode *olddir = (nfs_vnode *)_olddir;
1239 nfs_vnode *newdir = (nfs_vnode *)_newdir;
1240
1241 TOUCH(nfs);TOUCH(olddir);TOUCH(newdir);
1242
1243 TRACE("nfs_rename: fsid 0x%x, vnid 0x%Lx, oldname '%s', newdir 0x%Lx, newname '%s'\n", nfs->id, VNODETOVNID(olddir), oldname, VNODETOVNID(newdir), newname);
1244
1245 return ERR_UNIMPLEMENTED;
1246 }
1247
1248 int nfs_mkdir(fs_cookie _fs, fs_vnode _base_dir, const char *name)
1249 {
1250 nfs_fs *nfs = (nfs_fs *)_fs;
1251 nfs_vnode *dir = (nfs_vnode *)_base_dir;
1252 int err;
1253
1254 TOUCH(nfs);TOUCH(dir);
1255
1256 TRACE("nfs_mkdir: fsid 0x%x, vnid 0x%Lx, name '%s'\n", nfs->id, VNODETOVNID(dir), name);
1257
1258 mutex_lock(&dir->lock);
1259
1260 err = _nfs_create(nfs, dir, name, STREAM_TYPE_DIR, NULL);
1261
1262 mutex_unlock(&dir->lock);
1263
1264 return err;
1265 }
1266
1267 int nfs_rmdir(fs_cookie _fs, fs_vnode _base_dir, const char *name)
1268 {
1269 nfs_fs *nfs = (nfs_fs *)_fs;
1270 nfs_vnode *dir = (nfs_vnode *)_base_dir;
1271 int err;
1272
1273 TOUCH(nfs);TOUCH(dir);
1274
1275 TRACE("nfs_rmdir: fsid 0x%x, vnid 0x%Lx, name '%s'\n", nfs->id, VNODETOVNID(dir), name);
1276
1277 mutex_lock(&dir->lock);
1278
1279 err = _nfs_unlink(nfs, dir, name, STREAM_TYPE_DIR);
1280
1281 mutex_unlock(&dir->lock);
1282
1283 return err;
1284 }
1285
1286 static int nfs_getattr(nfs_fs *nfs, nfs_vnode *v, uint8 *buf, nfs_attrstat *attrstat)
1287 {
1288 int err;
1289
1290 err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, NFSPROC_GETATTR, &v->nfs_handle, sizeof(v->nfs_handle), buf, NFS_ATTRSTAT_MAXLEN);
1291 if (err < 0)
1292 return err;
1293
1294 nfs_unpack_attrstat(buf, attrstat);
1295
1296 return nfs_status_to_error(attrstat->status);
1297 }
1298
1299 int nfs_rstat(fs_cookie fs, fs_vnode _v, struct file_stat *stat)
1300 {
1301 nfs_fs *nfs = (nfs_fs *)fs;
1302 nfs_vnode *v = (nfs_vnode *)_v;
1303 uint8 attrstatbuf[NFS_ATTRSTAT_MAXLEN];
1304 nfs_attrstat attrstat;
1305 int err;
1306
1307 TRACE("nfs_rstat: fsid 0x%x, vnid 0x%Lx, stat %p\n", nfs->id, VNODETOVNID(v), stat);
1308
1309 mutex_lock(&v->lock);
1310
1311 err = nfs_getattr(nfs, v, attrstatbuf, &attrstat);
1312 if(err < 0)
1313 goto out;
1314
1315 if(attrstat.status != NFS_OK) {
1316 err = ERR_IO_ERROR;
1317 goto out;
1318 }
1319
1320 /* copy the stat over from the nfs attrstat */
1321 stat->vnid = VNODETOVNID(v);
1322 stat->size = attrstat.attributes->size;
1323 switch(attrstat.attributes->ftype) {
1324 case NFREG:
1325 stat->type = STREAM_TYPE_FILE;
1326 break;
1327 case NFDIR:
1328 stat->type = STREAM_TYPE_DIR;
1329 break;
1330 default:
1331 stat->type = STREAM_TYPE_DEVICE; // XXX should have unknown type
1332 break;
1333 }
1334
1335 err = NO_ERROR;
1336
1337 out:
1338 mutex_unlock(&v->lock);
1339
1340 return err;
1341 }
1342
1343 int nfs_wstat(fs_cookie fs, fs_vnode _v, struct file_stat *stat, int stat_mask)
1344 {
1345 nfs_fs *nfs = (nfs_fs *)fs;
1346 nfs_vnode *v = (nfs_vnode *)_v;
1347
1348 TOUCH(nfs);TOUCH(v);
1349
1350 TRACE("nfs_wstat: fsid 0x%x, vnid 0x%Lx, stat %p, stat_mask 0x%x\n", nfs->id, VNODETOVNID(v), stat, stat_mask);
1351
1352 return ERR_UNIMPLEMENTED;
1353 }
1354
1355 static struct fs_calls nfs_calls = {
1356 &nfs_mount,
1357 &nfs_unmount,
1358 &nfs_sync,
1359
1360 &nfs_lookup,
1361
1362 &nfs_getvnode,
1363 &nfs_putvnode,
1364 &nfs_removevnode,
1365
1366 &nfs_opendir,
1367 &nfs_closedir,
1368 &nfs_rewinddir,
1369 &nfs_readdir,
1370
1371 &nfs_open,
1372 &nfs_close,
1373 &nfs_freecookie,
1374 &nfs_fsync,
1375
1376 &nfs_read,
1377 &nfs_write,
1378 &nfs_seek,
1379 &nfs_ioctl,
1380
1381 &nfs_canpage,
1382 &nfs_readpage,
1383 &nfs_writepage,
1384
1385 &nfs_create,
1386 &nfs_unlink,
1387 &nfs_rename,
1388
1389 &nfs_mkdir,
1390 &nfs_rmdir,
1391
1392 &nfs_rstat,
1393 &nfs_wstat
1394 };
1395
1396 int fs_bootstrap(void);
1397 int fs_bootstrap(void)
1398 {
1399 dprintf("bootstrap_nfs: entry\n");
1400 return vfs_register_filesystem("nfs", &nfs_calls);
1401 }
1402
A new operating system