Newsgroup: it.comp.os.linux.development
Titolo: thread ae blocco parziale di un file

ciao a tutti
sto scrivendo un editor di testo condiviso in linguaccio C. Qualcuno sa
come fare a bloccare singole parti di un file? Io sto provando con i
pthread, mutex e semafori...ma nn ho capito bene come funzionano!
Help me!

 come fare a bloccare singole parti di un file?
Guarda lockf(3).
Ma per capire se è la cosa giusta, bisogna capire bene cosa vuoi fare.
-- 
   |   \    \  | ___|_  |_  |  ianezz a casa sua... :-)
   |  _ \  | \ | _|    /   /   Verba volant, scripta
  _|_/  _\_|  _|____|___|___|  manent, data corrupted

devo poter bloccare singole parti di un file per poter essere condiviso
e modificato da più utnati. sto utilizzando i pthread ma nn riesco a
capire bene come fare....thanks

 e modificato da più utnati.
Spiegati meglio: vuoi che
  - se ci sono più utenti che editano lo stesso file, tutti eccetto il
    primo che l'ha aperto siano notificati che c'è qualcuno che ci sta
    lavorando?
  - o avere una specie di "lavagna" in cui tutti possono fare modifiche
    in punti diversi e ognuno vede le modifiche che stanno facendo gli
    altri?
In entrambi i casi non vedo né la necessità dei pthread, né di porre dei 
lock su parte del file (


allora ti spiego: c'è un file di testo ke si trova su un serve al
quale più utenti possono accedere. Ogni utente deve poter modificare
contemporanenamente diverse parti dello stesso file ma nn la stessa.
Devo usare i thread xchè è una tesina x sistemi operativi.
tu ke mi consigli? thanks

 contemporanenamente diverse parti dello stesso file ma nn la stessa.
Inizia a definire cos'è una "parte di file".
Poi cerca di scrivere come i cristiani (o i pastafarianti), altrimenti farai
scappare le eventuali risposte.
Ciao,
-- 
  Daniele Orlandi



L'argomento non e` per niente banale.
Se tutti gli "editori" sono nello stesso PC (come presumo, essendo un
esame di S.O.) puoi mappare in memoria il file e lockarne le parti con
semafori o altre IPC.
Se sono in rete devi per forza scriverti un daemon che mappi il file e
tenga conto dei lock. Stanno sviluppando un editor per Gnome che fa
queste cose, ma non mi ricordo come si chiama. :/
Bye.
-- 
Alessandro Pellizzari

come faccio a fare un daemon...mica sono un mago!? :-)

come faccio a definire una parte di file?

 come faccio a definire una parte di file?
Rispondi alla domanda "cosa è una parte di file"?
Un carattere? Una linea? Un unsieme di linee? Quanto grande?
Ciao,
-- 
  Daniele Orlandi

ehmmm....volevo dire come faccio a bloccare solo quella parte di file e
nn tutto il file!!?

 nn tutto il file!!?
Le mie domande non sono fini a loro stesse, è tutto lì il problema. Cerca di
capire COSA vuoi lockare.
Ciao,
-- 
 Daniele Orlandi                                                        つづく

devo mappare il file in memoria tenendo conto dei lock nelle diverse
parti?

 nn tutto il file!!?
Come ti dicevo, per acquisire, rilasciare o semplicemente testare un 
lock su una parte di un file usi lockf() con i parametri del caso.
"man lockf" per i dettagli.
Resta da capire cosa si intenda con ciò che tu definisci "quella parte".
Tieni presente che, per come son fatti i filesystem:
  - non c'è modo di "inserire" dei byte in mezzo ad un file senza dover
    copiare in avanti manualmente tutti i byte che seguono il punto di
    inserimento, né è possibile rimuovere dei byte in mezzo ad un file
    ed accorciarlo senza creare un nuovo file più corto da dove siano
    stati copiati i byte del primo eccetto quelli che vuoi rimuovere, e
    poi sostituirlo al file originale.
  - lockf() gestisce lock su porzioni di file definite in termini di
    numero di byte da lockare a partire da una posizione espressa in
    un certo numero di byte a partire dall'inizio del file. I lock
    non si possono "spostare".
  - per queste ragioni gli editor di testi, che per definirsi tali
    debbono poter permettere di inserire o togliere del testo che
    si trova in mezzo a dell'altro testo, normalmente lavorano su
    strutture in memoria che sono diverse da quelle che invece
    sono sui file, costruendo queste strutture all'atto del caricamento
    da file, alterandole in fase di editing, e producendo un file
    lineare in fase di salvataggio.
A questo punto ti dovrebbe essere chiaro il perché ho seri dubbi che un 
lock su una porzione di un file possa realmente servirti a qualcosa, 
eccetto nel caso in cui le dimensioni di tali parti siano fisse e note a 
priori.
+++
Personalmente mi verrebbe da implementare il tutto come un processo 
server che internamente funzioni come un qualsiasi editor di testi, ma 
che al posto di un'interfaccia utente esponga un'interfaccia applicativa 
a dei client, facendo da arbitro per tutto l'editing che i client gli 
richiedono di fare in base alle parti del testo che le richieste vanno a 
modificare e a quale client ha fatto la richiesta.
Poi farei un client che implementa l'interfaccia utente, che parla col 
server tramite qualche forma di IPC (socket, fifo, memoria condivisa, 
etc.) chidendogli di applicare le modifiche richieste dall'utente e 
gestendo sia il caso in cui il server risponda positivamente, sia il 
caso in cui il server risponda picche (perché le modifiche andrebbero a 
collidere con quelle fatte da un altro utente).
Ma prima di implementare qualsiasi cosa, cercherei di definire bene i 
criteri con cui determinare i confini precisi delle parti di testo che 
un utente non può modificare perché modificate da un altro utente, cosa 
che non mi sembra affatto ovvia.
Notare comunque che per far questo i thread non servono affatto, a meno 
che tu non voglia implementare client e server nello stesso processo 
(nel qual caso c'è il problema più sottile di gestire dallo stesso 
processo più interfacce utente su più display diversi in maniera 
concorrente), e comunque pure in quel caso, probabilmente, se ne riesce 
a fare a meno (con un ciclo degli eventi opportunamente progettato).


ciao ianezz
intanto ti ringrazio x aver risposto in maniera così appronf alla mia
domanda. :-)
In parte ho già fatto quello ke mi ha suggerito...ho fatto un server
che accoglie le richieste dei client, tramite socket.
Per quanto riguarda la parte client, ognuno di loro presenta una
interfaccia grafica tipica di ogni editor di testo. Il server invece è
quello che nn riesco ad implementare.
xchè?
te lo spiego...ogni client può aprire un file di testo che si trova
nel server, selezionare una parte di testo che vuole modificare e a
questo punto bloccarlo in modo tale da escludere qualunque altro client
da una ipotetica modifica. In questo modo faccio arrivare al server i
confini ben precisi per bloccare la parte del file. E poi? come posso
bloccaresolo quella parte in attesa che poi il client mi mandi la parte
da sostituire? Ti dico questo xchè l'utente può intanto bloccare la
parte e decidere di modificare in seguito. Non solo...un utente
dovrebbe anche vedere in real time le modifiche fatte da tutti gli
altri utenti mentre sta modficicando la propria parte bloccata! E'
utile mapparsi in memoria tutto il file o solo la parte del file da
bloccare?
Non voglio stressarti...ma se hai delle idee interessanti ti prego di
espormele, Thanks