gtfs: Fix has_children()
[akaros.git] / kern / drivers / dev / gtfs.c
1 /* Copyright (c) 2018 Google Inc
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * #gtfs, generic tree file system frontend that hooks to a backend 9p device
6  */
7
8 #include <slab.h>
9 #include <kmalloc.h>
10 #include <kref.h>
11 #include <string.h>
12 #include <stdio.h>
13 #include <assert.h>
14 #include <error.h>
15 #include <pmap.h>
16 #include <smp.h>
17 #include <tree_file.h>
18
19 struct dev gtfs_devtab;
20
21 static char *devname(void)
22 {
23         return gtfs_devtab.name;
24 }
25
26 struct gtfs {
27         struct tree_filesystem          tfs;
28         struct kref                                     users;
29 };
30
31 /* Blob hanging off the fs_file->priv.  The backend chans are only accessed,
32  * (changed or used) with the corresponding fs_file qlock held.  That's the
33  * primary use of the qlock - we might be able to avoid qlocking with increfs
34  * and atomics or spinlocks, but be careful of be_length.  Qlocking doesn't
35  * matter much yet since #mnt serializes.
36  *
37  * The walk chan is never opened - it's basically just the walked fid, from
38  * which we can do other walks or get the I/O chans.  The read and write chans
39  * are opened on demand and closed periodically.  We open them initially on
40  * open/create in case we are unable to open them (e.g. unwritable).  Better to
41  * find out early than during a long writeback.
42  *
43  * The mnt server might complain about having too many open fids.  We can run a
44  * ktask that periodically closes the be_chans on any LRU'd files.
45  *
46  * be_{length,mode,mtime} should be what the remote server thinks they are -
47  * especially for length and mode.  The invariant is that e.g. the file's length
48  * == be_length, and the qlock protects that invariant.  We don't care as much
49  * about mtime, since some 9p servers just change that on their own. */
50 struct gtfs_priv {
51         struct chan                                     *be_walk;       /* never opened */
52         struct chan                                     *be_read;
53         struct chan                                     *be_write;
54         uint64_t                                        be_length;
55         uint32_t                                        be_mode;
56         struct timespec                         be_mtime;
57         bool                                            was_removed;
58 };
59
60 static inline struct gtfs_priv *fsf_to_gtfs_priv(struct fs_file *f)
61 {
62         return f->priv;
63 }
64
65 static inline struct gtfs_priv *tf_to_gtfs_priv(struct tree_file *tf)
66 {
67         return fsf_to_gtfs_priv(&tf->file);
68 }
69
70 /* Helper.  Clones the chan (walks to itself) and then opens with omode. */
71 static struct chan *cclone_and_open(struct chan *c, int omode)
72 {
73         ERRSTACK(1);
74         struct chan *new;
75
76         new = cclone(c);
77         if (waserror()) {
78                 cclose(new);
79                 nexterror();
80         }
81         new = devtab[new->type].open(new, omode);
82         poperror();
83         return new;
84 }
85
86 /* Send a wstat with the contents of dir for the file. */
87 static void wstat_dir(struct fs_file *f, struct dir *dir)
88 {
89         ERRSTACK(1);
90         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
91         size_t sz;
92         uint8_t *buf;
93
94         sz = sizeD2M(dir);
95         buf = kzmalloc(sz, MEM_WAIT);
96         convD2M(dir, buf, sz);
97         if (waserror()) {
98                 kfree(buf);
99                 nexterror();
100         }
101         devtab[gp->be_walk->type].wstat(gp->be_walk, buf, sz);
102         kfree(buf);
103         poperror();
104 }
105
106 /* Note we only track and thus change the following:
107  * - length
108  * - mode
109  * - mtime (second granularity)
110  * If we support chown, we'll have to do something else there.  See
111  * fs_file_copy_from_dir(). */
112 static void sync_metadata(struct fs_file *f)
113 {
114         ERRSTACK(1);
115         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
116         struct dir dir;
117         bool send_it = false;
118
119         qlock(&f->qlock);
120         init_empty_dir(&dir);
121         if (f->dir.length != gp->be_length) {
122                 dir.length = f->dir.length;
123                 send_it = true;
124         }
125         if (f->dir.mode != gp->be_mode) {
126                 dir.mode = f->dir.mode;
127                 send_it = true;
128         }
129         if (f->dir.mtime.tv_sec != gp->be_mtime.tv_sec) {
130                 /* ninep's UFS server assumes you set both atime and mtime */
131                 dir.atime.tv_sec = f->dir.atime.tv_sec;
132                 dir.atime.tv_nsec = f->dir.atime.tv_nsec;
133                 dir.mtime.tv_sec = f->dir.mtime.tv_sec;
134                 dir.mtime.tv_nsec = f->dir.mtime.tv_nsec;
135                 send_it = true;
136         }
137         if (!send_it) {
138                 qunlock(&f->qlock);
139                 return;
140         }
141         if (waserror()) {
142                 qunlock(&f->qlock);
143                 nexterror();
144         }
145         wstat_dir(f, &dir);
146         /* We set these after the wstat succeeds.  If we set them earlier, we'd have
147          * to roll back.  Remember the invariant: the be_values match the backend's
148          * file's values.  We should be able to stat be_walk and check these (though
149          * the 9p server might muck with atime/mtime). */
150         if (f->dir.length != gp->be_length)
151                 gp->be_length = f->dir.length;
152         if (f->dir.mode != gp->be_mode)
153                 gp->be_mode = f->dir.mode;
154         if (f->dir.mtime.tv_sec != gp->be_mtime.tv_sec)
155                 gp->be_mtime = f->dir.mtime;
156         qunlock(&f->qlock);
157         poperror();
158 }
159
160 /* Can throw on error, currently from sync_metadata. */
161 static void writeback_file(struct fs_file *f)
162 {
163         sync_metadata(f);
164         /* This is a lockless peak.  Once a file is dirtied, we never undirty it.
165          * To do so, we need the file qlock (not a big deal, though that may replace
166          * the PM qlock), and we still need to handle/scan mmaps.  Specifically, we
167          * only dirty when an mmap attaches (PROT_WRITE and MAP_SHARED), but we
168          * don't know if an existing mapping has caused more dirtying (an mmap can
169          * re-dirty then detach before our next writeback).  That usually requires a
170          * scan.  This is all an optimization to avoid scanning the entire PM's
171          * pages for whether or not they are dirty.
172          *
173          * Also, our writeback pm op grabs the file's qlock.  So be careful; though
174          * we could use another qlock, since we're mostly protecting backend state.
175          */
176         if (qid_is_file(f->dir.qid) && (f->flags & FSF_DIRTY))
177                 pm_writeback_pages(f->pm);
178 }
179
180 static void purge_cb(struct tree_file *tf)
181 {
182         ERRSTACK(1)
183
184         /* discard error, and keep on going if we can. */
185         if (!waserror())
186                 writeback_file(&tf->file);
187         poperror();
188 }
189
190 static void gtfs_release(struct kref *kref)
191 {
192         struct gtfs *gtfs = container_of(kref, struct gtfs, users);
193
194         tfs_frontend_purge(&gtfs->tfs, purge_cb);
195         /* this is the ref from attach */
196         assert(kref_refcnt(&gtfs->tfs.root->kref) == 1);
197         tf_kref_put(gtfs->tfs.root);
198         /* ensures __tf_free() happens before tfs_destroy */
199         rcu_barrier();
200         tfs_destroy(&gtfs->tfs);
201         kfree(gtfs);
202 }
203
204 static struct gtfs *chan_to_gtfs(struct chan *c)
205 {
206         struct tree_file *tf = chan_to_tree_file(c);
207
208         return (struct gtfs*)(tf->tfs);
209 }
210
211 static void incref_gtfs_chan(struct chan *c)
212 {
213         kref_get(&chan_to_gtfs(c)->users, 1);
214 }
215
216 static void decref_gtfs_chan(struct chan *c)
217 {
218         kref_put(&chan_to_gtfs(c)->users);
219 }
220
221 static struct walkqid *gtfs_walk(struct chan *c, struct chan *nc, char **name,
222                                  unsigned int nname)
223 {
224         struct walkqid *wq;
225
226         wq = tree_chan_walk(c, nc, name, nname);
227         if (wq && wq->clone && (wq->clone != c))
228                 incref_gtfs_chan(wq->clone);
229         return wq;
230 }
231
232 /* Given an omode, make sure the be chans are set up */
233 static void setup_be_chans(struct chan *c, int omode)
234 {
235         ERRSTACK(1);
236         struct tree_file *tf = chan_to_tree_file(c);
237         struct fs_file *f = &tf->file;
238         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
239
240         qlock(&f->qlock);
241         if (waserror()) {
242                 qunlock(&f->qlock);
243                 nexterror();
244         }
245         /* Readers and writers both need be_read.  With fs files you can't have a
246          * writable-only file, since we need to load the page into the page cache,
247          * which is a readpage. */
248         if (!gp->be_read)
249                 gp->be_read = cclone_and_open(gp->be_walk, O_READ);
250         if (!gp->be_write && (omode & O_WRITE))
251                 gp->be_write = cclone_and_open(gp->be_walk, O_WRITE);
252         qunlock(&f->qlock);
253         poperror();
254 }
255
256 static struct chan *gtfs_open(struct chan *c, int omode)
257 {
258         /* truncate can happen before we setup the be_chans.  if we need those, we
259          * can swap the order */
260         c = tree_chan_open(c, omode);
261         setup_be_chans(c, omode);
262         return c;
263 }
264
265
266 static void gtfs_create(struct chan *c, char *name, int omode, uint32_t perm,
267                         char *ext)
268 {
269         tree_chan_create(c, name, omode, perm, ext);
270         /* We have to setup *after* create, since it moves the chan from the parent
271          * to the new file. */
272         setup_be_chans(c, omode);
273 }
274
275 static void gtfs_close(struct chan *c)
276 {
277         tree_chan_close(c);
278         decref_gtfs_chan(c);
279 }
280
281 static void gtfs_remove(struct chan *c)
282 {
283         ERRSTACK(1);
284         struct gtfs *gtfs = chan_to_gtfs(c);
285
286         if (waserror()) {
287                 /* Same old pain-in-the-ass for remove */
288                 kref_put(&gtfs->users);
289                 nexterror();
290         }
291         tree_chan_remove(c);
292         kref_put(&gtfs->users);
293         poperror();
294 }
295
296 static size_t gtfs_wstat(struct chan *c, uint8_t *m_buf, size_t m_buf_sz)
297 {
298         size_t ret;
299
300         ret = tree_chan_wstat(c, m_buf, m_buf_sz);
301         /* Tell the backend so that any metadata changes take effect immediately.
302          * Consider chmod +w.  We need to tell the 9p server so that it will allow
303          * future accesses. */
304         sync_metadata(&chan_to_tree_file(c)->file);
305         return ret;
306 }
307
308 /* Caller holds the file's qlock. */
309 static size_t __gtfs_fsf_read(struct fs_file *f, void *ubuf, size_t n,
310                               off64_t off)
311 {
312         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
313
314         if (off >= gp->be_length) {
315                 /* We can skip the RPC, since we know it will return zero (EOF). */
316                 return 0;
317         }
318         if (!gp->be_read)
319                 gp->be_read = cclone_and_open(gp->be_walk, O_READ);
320         return devtab[gp->be_read->type].read(gp->be_read, ubuf, n, off);
321 }
322
323 /* Reads a file from its backend chan */
324 static size_t gtfs_fsf_read(struct fs_file *f, void *ubuf, size_t n,
325                             off64_t off)
326 {
327         ERRSTACK(1);
328         size_t ret;
329
330         qlock(&f->qlock);
331         if (waserror()) {
332                 qunlock(&f->qlock);
333                 nexterror();
334         }
335         ret = __gtfs_fsf_read(f, ubuf, n, off);
336         qunlock(&f->qlock);
337         poperror();
338         return ret;
339 }
340
341 /* Caller holds the file's qlock. */
342 static size_t __gtfs_fsf_write(struct fs_file *f, void *ubuf, size_t n,
343                                off64_t off)
344 {
345         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
346         size_t ret;
347
348         if (!gp->be_write)
349                 gp->be_write = cclone_and_open(gp->be_walk, O_WRITE);
350         ret = devtab[gp->be_write->type].write(gp->be_write, ubuf, n, off);
351         gp->be_length = MAX(gp->be_length, n + ret);
352         return ret;
353 }
354
355 /* Writes a file to its backend chan */
356 static size_t gtfs_fsf_write(struct fs_file *f, void *ubuf, size_t n,
357                              off64_t off)
358 {
359         ERRSTACK(1);
360         size_t ret;
361
362         qlock(&f->qlock);
363         if (waserror()) {
364                 qunlock(&f->qlock);
365                 nexterror();
366         }
367         ret = __gtfs_fsf_write(f, ubuf, n, off);
368         qunlock(&f->qlock);
369         poperror();
370         return ret;
371 }
372
373 static size_t gtfs_read(struct chan *c, void *ubuf, size_t n, off64_t off)
374 {
375         struct tree_file *tf = chan_to_tree_file(c);
376
377         if (tree_file_is_dir(tf))
378                 return gtfs_fsf_read(&tf->file, ubuf, n, off);
379         return fs_file_read(&tf->file, ubuf, n, off);
380 }
381
382 /* Given a file (with dir->name set), couple it and sync to the backend chan.
383  * This will store/consume the ref for backend, in the TF (freed with
384  * gtfs_tf_free), even on error, unless you zero out the be_walk field. */
385 static void gtfs_tf_couple_backend(struct tree_file *tf, struct chan *backend)
386 {
387         struct dir *dir;
388         struct gtfs_priv *gp = kzmalloc(sizeof(struct gtfs_priv), MEM_WAIT);
389
390         tf->file.priv = gp;
391         tf->file.dir.qid = backend->qid;
392         gp->be_walk = backend;
393         dir = chandirstat(backend);
394         if (!dir)
395                 error(ENOMEM, "chandirstat failed");
396         fs_file_copy_from_dir(&tf->file, dir);
397         kfree(dir);
398         /* For sync_metadata */
399         gp->be_length = tf->file.dir.length;
400         gp->be_mode = tf->file.dir.mode;
401         gp->be_mtime = tf->file.dir.mtime;
402 }
403
404 static void gtfs_tf_free(struct tree_file *tf)
405 {
406         struct gtfs_priv *gp = tf_to_gtfs_priv(tf);
407
408         /* Might have some partially / never constructed tree files */
409         if (!gp)
410                 return;
411         if (gp->was_removed) {
412                 gp->be_walk->type = -1;
413                 /* sanity */
414                 assert(kref_refcnt(&gp->be_walk->ref) == 1);
415         }
416         cclose(gp->be_walk);
417         /* I/O chans can be NULL */
418         cclose(gp->be_read);
419         cclose(gp->be_write);
420         kfree(gp);
421 }
422
423 static void gtfs_tf_unlink(struct tree_file *parent, struct tree_file *child)
424 {
425         struct gtfs_priv *gp = tf_to_gtfs_priv(child);
426         struct chan *be_walk = gp->be_walk;
427
428         /* Remove clunks the be_walk chan/fid.  if it succeeded (and I think even if
429          * it didn't), we shouldn't close that fid again, which is what will happen
430          * soon after this function.  The TF code calls unlink, then when the last
431          * ref closes the TF, it'll get freed and we'll call back to gtfs_tf_free().
432          *
433          * This is the same issue we run into with all of the device remove ops
434          * where we want to refcnt something hanging off e.g. c->aux.  In 9p, you're
435          * not supposed to close a chan/fid that was already removed.
436          *
437          * Now here's the weird thing.  We can close the be_walk chan after remove,
438          * but it's possible that someone has walked and perhaps opened a frontend
439          * chan + TF, but hasn't done a read yet.  So someone might want to set up
440          * be_read, but they can't due to be_walk being closed.  We could give them
441          * a 'phase error' (one of 9p's errors for I/O on a removed file).
442          *
443          * Alternatively, we can mark the gtfs_priv so that when we do free it, we
444          * skip the dev.remove, similar to what sysremove() does.  That's probably
445          * easier.  This is technically racy, but we know that the release/free
446          * method won't be called until we return. */
447         gp->was_removed = true;
448         devtab[be_walk->type].remove(be_walk);
449 }
450
451 /* Caller sets the name, but doesn't know if it exists or not.  It's our job to
452  * find out if it exists and fill in the child structure appropriately.  For
453  * negative entries, just flagging it is fine.  Otherwise, we fill in the dir.
454  * We should throw on error. */
455 static void gtfs_tf_lookup(struct tree_file *parent, struct tree_file *child)
456 {
457         struct walkqid *wq;
458         struct chan *be_walk = tf_to_gtfs_priv(parent)->be_walk;
459         struct chan *child_be_walk;
460
461         wq = devtab[be_walk->type].walk(be_walk, NULL, &child->file.dir.name, 1);
462         if (!wq || !wq->clone) {
463                 kfree(wq);
464                 /* This isn't racy, since the child isn't linked to the tree yet */
465                 child->flags |= TF_F_NEGATIVE | TF_F_HAS_BEEN_USED;
466                 return;
467         }
468         /* walk shouldn't give us the same chan struct since we gave it a name and a
469          * NULL nc. */
470         assert(wq->clone != be_walk);
471         /* only gave it one name, and it didn't fail. */
472         assert(wq->nqid == 1);
473         /* sanity */
474         assert(wq->clone->qid.path == wq->qid[wq->nqid - 1].path);
475         child_be_walk = wq->clone;
476         kfree(wq);
477         gtfs_tf_couple_backend(child, child_be_walk);
478 }
479
480 static void gtfs_tf_create(struct tree_file *parent, struct tree_file *child,
481                            int perm)
482 {
483         ERRSTACK(1);
484         struct chan *c = cclone(tf_to_gtfs_priv(parent)->be_walk);
485
486         if (waserror()) {
487                 cclose(c);
488                 nexterror();
489         }
490         devtab[c->type].create(c, tree_file_to_name(child), 0, perm,
491                                child->file.dir.ext);
492         /* The chan c is opened, which we don't want.  We can't cclone it either
493          * (since it is opened).  All we can do is have the parent walk again so we
494          * can get the child's unopened be_walk chan.  Conveniently, that's
495          * basically a lookup, so create is really two things: make it, then look it
496          * up from the backend. */
497         cclose(c);
498         poperror();
499         if (waserror()) {
500                 warn("File %s was created in the backend, but unable to look it up!",
501                      tree_file_to_name(child));
502                 nexterror();
503         }
504         gtfs_tf_lookup(parent, child);
505         poperror();
506 }
507
508 static void gtfs_tf_rename(struct tree_file *tf, struct tree_file *old_parent,
509                            struct tree_file *new_parent, const char *name,
510                            int flags)
511 {
512         struct chan *tf_c = tf_to_gtfs_priv(tf)->be_walk;
513         struct chan *np_c = tf_to_gtfs_priv(new_parent)->be_walk;
514
515         if (!devtab[tf_c->type].rename)
516                 error(EXDEV, "%s: %s doesn't support rename", devname(),
517                       devtab[tf_c->type].name);
518         devtab[tf_c->type].rename(tf_c, np_c, name, flags);
519 }
520
521 static bool gtfs_tf_has_children(struct tree_file *parent)
522 {
523         struct dir dir[1];
524
525         assert(tree_file_is_dir(parent));       /* TF bug */
526         /* Any read should work, but there might be issues asking for something
527          * smaller than a dir.
528          *
529          * Note we use the unlocked read here.  The fs_file's qlock is held by our
530          * caller, and we reuse that qlock for the sync for reading/writing. */
531         return __gtfs_fsf_read(&parent->file, dir, sizeof(struct dir), 0) > 0;
532 }
533
534 struct tree_file_ops gtfs_tf_ops = {
535         .free = gtfs_tf_free,
536         .unlink = gtfs_tf_unlink,
537         .lookup = gtfs_tf_lookup,
538         .create = gtfs_tf_create,
539         .rename = gtfs_tf_rename,
540         .has_children = gtfs_tf_has_children,
541 };
542
543 /* Fills page with its contents from its backing store file.
544  *
545  * Note the page/offset might be beyond the current file length, based on the
546  * current pagemap code. */
547 static int gtfs_pm_readpage(struct page_map *pm, struct page *pg)
548 {
549         ERRSTACK(1);
550         void *kva = page2kva(pg);
551         off64_t offset = pg->pg_index << PGSHIFT;
552         size_t ret;
553
554         if (waserror()) {
555                 poperror();
556                 return -get_errno();
557         }
558         /* If offset is beyond the length of the file, the 9p device/server should
559          * return 0.  We'll just init an empty page.  The length on the frontend (in
560          * the fsf->dir.length) will be adjusted.  The backend will hear about it on
561          * the next sync. */
562         ret = gtfs_fsf_read(pm->pm_file, kva, PGSIZE, offset);
563         poperror();
564         if (ret < PGSIZE)
565                 memset(kva + ret, 0, PGSIZE - ret);
566         atomic_or(&pg->pg_flags, PG_UPTODATE);
567         return 0;
568 }
569
570 /* Meant to take the page from PM and flush to backing store. */
571 static int gtfs_pm_writepage(struct page_map *pm, struct page *pg)
572 {
573         ERRSTACK(1);
574         struct fs_file *f = pm->pm_file;
575         void *kva = page2kva(pg);
576         off64_t offset = pg->pg_index << PGSHIFT;
577         size_t amt;
578
579         qlock(&f->qlock);
580         if (waserror()) {
581                 qunlock(&f->qlock);
582                 poperror();
583                 return -get_errno();
584         }
585         /* Don't writeback beyond the length of the file.  Most of the time this
586          * comes up is when the len is in the middle of the last page. */
587         if (offset >= fs_file_get_length(f)) {
588                 qunlock(&f->qlock);
589                 return 0;
590         }
591         amt = MIN(PGSIZE, fs_file_get_length(f) - offset);
592         __gtfs_fsf_write(f, kva, amt, offset);
593         qunlock(&f->qlock);
594         poperror();
595         return 0;
596 }
597
598 /* Caller holds the file's qlock */
599 static void __trunc_to(struct fs_file *f, off64_t begin)
600 {
601         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
602         struct dir dir;
603
604         init_empty_dir(&dir);
605         dir.length = begin;
606         wstat_dir(f, &dir);
607         /* recall the invariant: be_length == the backend's length */
608         gp->be_length = begin;
609 }
610
611 /* Caller holds the file's qlock */
612 static void __zero_fill(struct fs_file *f, off64_t begin, off64_t end)
613 {
614         ERRSTACK(1);
615         void *zeros;
616
617         if (PGOFF(begin) || PGOFF(end))
618                 error(EINVAL, "zero_fill had unaligned begin (%p) or end (%p)\n",
619                       begin, end);
620         zeros = kpages_zalloc(PGSIZE, MEM_WAIT);
621         if (waserror()) {
622                 kpages_free(zeros, PGSIZE);
623                 nexterror();
624         }
625         for (off64_t o = begin; o < end; o += PGSIZE)
626                 __gtfs_fsf_write(f, zeros, PGSIZE, o);
627         poperror();
628 }
629
630 /* The intent here is for the backend to drop all data in the range.  Zeros are
631  * OK - any future read should get a zero.
632  *
633  * These offsets are the beginning and end of the hole to punch.  The TF code
634  * already dealt with edge cases, so these happen to be page aligned.  That
635  * shouldn't matter for the backend device.
636  *
637  * Don't worry about a border page for end that is all zeros.
638  * fs_file_truncate() rounded up to the nearest page to avoid issues.  The user
639  * could manually punch a hole, and they could create a page of zeros at end.
640  * We don't care.
641  *
642  * 9p doesn't have a hole-punch, so we'll truncate if we can and o/w fill with
643  * zeros.
644  *
645  * Note that the frontend's file length often differs from the backend.  Under
646  * normal operation, such as writing to a file, the frontend's len will be
647  * greater than the backend's.  When we sync, the backend learns the real
648  * length.  Similarly, when we shrink a gile, the backend's length may be
649  * greater than the frontend.  Consider a truncate from 8192 to 4095: we punch
650  * with begin = 4096, end = 8192.  In either case, the backend learns the real
651  * length on a sync.  In punch_hole, we're just trying to discard old data. */
652 static void gtfs_fs_punch_hole(struct fs_file *f, off64_t begin, off64_t end)
653 {
654         ERRSTACK(1);
655         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
656
657         qlock(&f->qlock);
658         if (waserror()) {
659                 qunlock(&f->qlock);
660                 nexterror();
661         }
662         if (end >= gp->be_length) {
663                 if (begin < gp->be_length)
664                         __trunc_to(f, begin);
665         } else {
666                 __zero_fill(f, begin, end);
667         }
668         qunlock(&f->qlock);
669         poperror();
670 }
671
672 static bool gtfs_fs_can_grow_to(struct fs_file *f, size_t len)
673 {
674         /* TODO: are there any limits in 9p? */
675         return true;
676 }
677
678 struct fs_file_ops gtfs_fs_ops = {
679         .readpage = gtfs_pm_readpage,
680         .writepage = gtfs_pm_writepage,
681         .punch_hole = gtfs_fs_punch_hole,
682         .can_grow_to = gtfs_fs_can_grow_to,
683 };
684
685 /* We're passed a backend chan, usually of type #mnt, used for an uncached
686  * mount.  We call it 'backend.'  It is the result of an attach, e.g. mntattach.
687  * In the case of #mnt, this chan is different than the one that has the 9p
688  * server on the other side, called 'mchan'.  That chan is at backend->mchan,
689  * and also the struct mnt->c.  The struct mnt is shared by all mounts talking
690  * to the 9p server over the mchan, and is stored at mchan->mux.  Backend chans
691  * have a strong (counted) ref on the mchan.
692  *
693  * We create and return a chan of #gtfs, suitable for attaching to the
694  * namespace.  This chan will have the root TF hanging off aux, just like how
695  * any other attached TFS has a root TF.  #gtfs manages the linkage between a TF
696  * and the backend, which is the purpose of gtfs_priv.
697  *
698  * A note on refcounts: in the normal, uncached operation, the 'backend' chan
699  * has a ref (actually a chan kref, which you cclose) on the comms chan (mchan).
700  * We get one ref at mntattach time, and every distinct mntwalk gets another
701  * ref.  Those actually get closed in chanfree(), since they are stored at
702  * mchan.
703  *
704  * All gtfs *tree_files* have at least one refcounted chan corresponding to the
705  * file/FID on the backend server.  Think of it as a 1:1 connection, even though
706  * there is more than one chan.  The gtfs device can have many chans pointing to
707  * the same TF, which is kreffed.  That TF is 1:1 on a backend object.
708  *
709  * All walks from this attach point will get chans with TFs from this TFS and
710  * will incref the struct gtfs.
711  */
712 static struct chan *gtfs_attach(char *arg)
713 {
714         ERRSTACK(2);
715         struct chan *backend = (struct chan*)arg;
716         struct chan *frontend;
717         struct tree_filesystem *tfs;
718         struct gtfs *gtfs;
719
720         frontend = devattach(devname(), 0);
721         if (waserror()) {
722                 /* same as #mnt - don't cclose, since we don't want to devtab close, and
723                  * we know the ref == 1 here. */
724                 chanfree(frontend);
725                 nexterror();
726         }
727         gtfs = kzmalloc(sizeof(struct gtfs), MEM_WAIT);
728         /* This 'users' kref is the one that every distinct frontend chan has.
729          * These come from attaches and successful, 'moving' walks. */
730         kref_init(&gtfs->users, gtfs_release, 1);
731         tfs = (struct tree_filesystem*)gtfs;
732         /* This gives us one ref on root, released during gtfs_release().  name is
733          * set to ".", though that gets overwritten during coupling. */
734         tfs_init(tfs);
735         if (waserror()) {
736                 /* don't consume the backend ref on error, caller expects to have it */
737                 tf_to_gtfs_priv(tfs->root)->be_walk = NULL;
738                 /* ref from tfs_init.  this should free the TF. */
739                 tf_kref_put(tfs->root);
740                 tfs_destroy(tfs);
741                 kfree(gtfs);
742                 nexterror();
743         }
744         /* stores the ref for 'backend' inside tfs->root */
745         gtfs_tf_couple_backend(tfs->root, backend);
746         poperror();
747         tfs->tf_ops = gtfs_tf_ops;
748         tfs->fs_ops = gtfs_fs_ops;
749         /* need another ref on root for the frontend chan */
750         tf_kref_get(tfs->root);
751         chan_set_tree_file(frontend, tfs->root);
752         poperror();
753         return frontend;
754 }
755
756 static bool lru_prune_cb(struct tree_file *tf)
757 {
758         ERRSTACK(1);
759
760         if (waserror()) {
761                 /* not much to do - ssh the file out? */
762                 printk("Failed to sync file %s: %s\n", tree_file_to_name(tf),
763                        current_errstr());
764                 poperror();
765                 return false;
766         }
767         writeback_file(&tf->file);
768         poperror();
769         return true;
770 }
771
772 static void pressure_dfs_cb(struct tree_file *tf)
773 {
774         if (!tree_file_is_dir(tf))
775                 pm_free_unused_pages(tf->file.pm);
776 }
777
778 /* Under memory pressure, there are a bunch of things we can do. */
779 static void gtfs_free_memory(struct gtfs *gtfs)
780 {
781         /* This attempts to remove every file from the LRU.  It'll write back dirty
782          * files, then if they haven't been used since we started, it'll delete the
783          * frontend TF, which will delete the entire page cache entry.  The heavy
784          * lifting is done by TF code. */
785         tfs_lru_for_each(&gtfs->tfs, lru_prune_cb, -1);
786         /* This drops the negative TFs.  It's not a huge deal, since they are small,
787          * but perhaps it'll help. */
788         tfs_lru_prune_neg(&gtfs->tfs);
789         /* This will attempt to free memory from all files in the frontend,
790          * regardless of whether or not they are in use.  This might help if you
791          * have some large files that happened to be open. */
792         tfs_frontend_for_each(&gtfs->tfs, pressure_dfs_cb);
793 }
794
795 static void gtfs_sync_tf(struct tree_file *tf)
796 {
797         writeback_file(&tf->file);
798 }
799
800 static void gtfs_sync_gtfs(struct gtfs *gtfs)
801 {
802         tfs_frontend_for_each(&gtfs->tfs, gtfs_sync_tf);
803 }
804
805 /* chan_ctl or something can hook into these functions */
806 static void gtfs_sync_chan(struct chan *c)
807 {
808         gtfs_sync_tf(chan_to_tree_file(c));
809 }
810
811 static void gtfs_sync_chans_fs(struct chan *any_c)
812 {
813         gtfs_sync_gtfs(chan_to_gtfs(any_c));
814 }
815
816 static unsigned long gtfs_chan_ctl(struct chan *c, int op, unsigned long a1,
817                                    unsigned long a2, unsigned long a3,
818                                    unsigned long a4)
819 {
820         switch (op) {
821         case CCTL_SYNC:
822                 if (tree_file_is_dir(chan_to_tree_file(c)))
823                         gtfs_sync_chans_fs(c);
824                 else
825                         gtfs_sync_chan(c);
826                 return 0;
827         default:
828                 error(EINVAL, "%s does not support %d", __func__, op);
829         }
830 }
831
832 struct dev gtfs_devtab __devtab = {
833         .name = "gtfs",
834
835         .reset = devreset,
836         .init = devinit,
837         .shutdown = devshutdown,
838         .attach = gtfs_attach,
839         .walk = gtfs_walk,
840         .stat = tree_chan_stat,
841         .open = gtfs_open,
842         .create = gtfs_create,
843         .close = gtfs_close,
844         .read = gtfs_read,
845         .bread = devbread,
846         .write = tree_chan_write,
847         .bwrite = devbwrite,
848         .remove = gtfs_remove,
849         .wstat = gtfs_wstat,
850         .power = devpower,
851         .chaninfo = devchaninfo,
852         .mmap = tree_chan_mmap,
853         .chan_ctl = gtfs_chan_ctl,
854 };